Das Spring Framework wird aufgrund der Komplexität der Softwareentwicklung erstellt. Spring verwendet grundlegende Javabeans, um Dinge zu tun, die bisher nur von EJB möglich waren. Der Zweck von Spring beschränkt sich jedoch nicht auf die serverseitige Entwicklung. Aus Sicht der Einfachheit, Testbarkeit und der losen Kopplung können die meisten Java -Anwendungen vom Frühjahr profitieren. Die Feder ist eine leichte Kontrollinversion (IOC) und ein § orientiertes (AOP) Container-Framework.
◆ Zweck: Lösen Sie die Komplexität der Entwicklung von Unternehmensanwendungen
◆ Funktion: Verwenden Sie grundlegende Javabean anstelle von EJB und bietet mehr Unternehmensanwendungsfunktionen
◆ Geltungsbereich: Jede Java -Anwendung
Die Inversion der Kontrolle (IOC in englischer Abkürzung) gibt das Recht, Objekte für das Framework zu erstellen, was ein wichtiges Merkmal des Frameworks ist und kein besonderer Begriff für die objektorientierte Programmierung ist. Es enthält Abhängigkeitsinjektion und Abhängigkeits -Lookup. In der traditionellen Geschäftsschicht finden sich in der Geschäftsschicht neue Ressourcen, sodass die Kopplung (Interdependenz und Korrelation zwischen den Programmen) höher ist. Geben Sie nun den neuen Teil des Frühlings über, um hohe Zusammenhalt und niedrige Kopplung zu erreichen. Kurz gesagt: Ursprünglich würde die App die DAO -Schicht oder die DAO -Schicht -Methode neu verwenden, und jetzt wurden die neuen Rechte an den Frühling übergeben und welche Ressourcen aus dem Frühling benötigt wurden!
1. Laden Sie das für das Framework erforderliche Abhängigkeitspaket herunter
Die offizielle Spring -Website lautet: http://spring.io/
Laden Sie das JAR-Paket herunter: http://repo.springource.org/libs-release-local/org/springframework/spring
2. Importieren Sie das Basis -JAR -Paket
Tatsächlich umfassen die grundlegenden Kerngläser Bohnen; Kontext; Kernpakete, Ausdruckspakete, und die anderen hängen von log4j -Protokollen ab. Natürlich sind Frühlingsgläser mehr als das, sie werden in der späteren Phase langsam hinzugefügt.
3. Konfigurieren Sie die Log4J -Konfigurationsdatei
Die Protokolldatei ist im SRC -Verzeichnis definiert
### Direkte Protokollnachrichten an STDOut ###log4j.appender.stdout=org.apache.log4j.ConsoleAppenderlog4j.appender.stdout.Target=System.errlog4j.appender.stdout.layout=org.apache.log4j.PatternLayoutlog4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %C {1}: %l - %M %N ### Direktnachrichten an mylog.log einreichen ### log4j.appender.file = org.apache.log4j.fileAppenderLog4j.appender.file %c {1}: %l - %M %N ### Log -Level festlegen - Für mehr ausführliche Protokollierung Änderung 'Info' to 'Debug' ### Log4j.rootlogger = Info, StDout4. Testen Sie, ob die Protokolldatei erfolgreich bereitgestellt wird
Paket com.clj.demo1; import org.apache.log4j.logger; import org.junit.test;/** * Demo -Protokollnutzung * @Author Administrator * */public class Demo1 {// Protokollklasse private Protokoll -Logger -Logger.getlogger (Demo1.class); @Test public void run1 () {// Ändern Sie die Informationen im Attribut log4j.rootlogger, um auszuschalten, und log.info ("execute"); }}5. Definieren Sie eine Schnittstelle und implementieren Sie Klasse
Schnittstelle:
Paket com.clj.demo2; öffentliche Schnittstelle UserService {public void Sayshello ();}Implementierungsklasse
Paket com.clj.demo2; öffentliche Klasse UserServiceImpl implementiert UserService {private String -Name; public String getName () {return name; } public void setName (String -Name) {this.name = name; } public void init () {System.out.println ("initialize .."); } public void SayShello () {System.out.println ("Hallo Spring"+"/t"+Name); } public void destory () {System.out.println ("Destroy .."); }}6. Definieren Sie federspezifische Konfigurationsdateien
Definieren Sie den Namen von ApplicationContext.xml, der Speicherort ist SRC, das gleiche Verzeichnis wie die Protokolldatei, importieren Sie die entsprechenden Einschränkungen und injizieren Sie die Implementierungsklasse in die Konfigurationsdatei. Beginnen Sie einfach mit dem Anfang, verwenden Sie Bohnenbeschränkungen
<? xmlns: p = "http://www.springframework.org/schema/p" xsi: scheMalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring---Bringframe.org/schema/schema/schema/schema/schema/schema/schema/beans/spring---Bringframe.org/Schema/Beans/spring---Bringframe.org/Schema/Beans/Spring---BingrameWrate.org/Schema/Beans/spring---BringframeW. Tag 1. Der ID-Wert ist eindeutig (muss schreiben) 2. Hinweis: Klasse ist der Implementierungsklassenpath, keine Schnittstelle (muss schreiben) 3. Initialisierungsarbeit, bevor die Kernmethode ausgeführt wird (Wählen Sie schreiben) 4. Initialisierungsarbeit nach Ausführung der Kernmethode (auswählen)-> <bean id = "userservice" init-method = "initory-method =" ”-Fobilien-Name"> </> </> <Stworks ". </bean> </beans>
7. Test
public class Demo1 { /*** Original Way* /@test public void run () {// Implementierungsklasse UserServiceImpl s = new UserServiceImpl (); S.SetName ("Jaxiansen"); S. sayhello (); } / *** Alte Fabrikversion BeanFactory* Old Factory erstellt keine Konfigurationsdateiobjekte* / @test public void run2 () {beanfactory factory = new XmlBeanFactory (neuer klassenpatresource ("applicationContext.xml"); UserService US = (UserService) Factory.getBean ("UserService"); us.sayhello (); } /*** Verwenden Sie die Spring Framework IOC -Methode* Erstellen Sie einen Start -Server in der neuen Version der Fabrik, um ein Konfigurationsdateiobjekt zu erstellen, und es müssen keine Fabrik geladen werden, wenn Sie erneut aufrufen* /@Test public void Run3 () {// Erstellen Sie die Fabrik und laden Sie die Kernkonfigurationsdatei (classpathXmlApplicationContext ua unter src) application context acc = New ClassPathXmlApplicationContext ("ApplicationContext.xml"); // das Objekt aus der Fabrik abrufen (ID -Wert in der Konfigurationsdatei, Polymorphism wird hier verwendet) Userservice usi = (UserService) ac.getbean ("UserService"); // Aufrufen der Methode des Objekts zur Ausführung usi.sayhello (); } /*** Demo-Zerstörungsmethode* Die Bean-Zerstörungsmethode wird nicht automatisch ausgeführt.* Wenn sie nicht automatisch in Scope = Singleton oder in einem Webcontainer genannt wird, muss die Hauptfunktion oder der Testfall manuell aufgerufen werden (müssen die Methode close () der KlassenpathxmlApplication CONTEXT @Test öffentlich () {// // // // // // // // // // // // // // creatory a factorycontext) genannt werden. (ClassPathXmlApplicationContext wird unter SRC gefunden) classPathXmlApplicationContext ac = new classMlMlApplicationContext ("applicationContext.xml"); // das Objekt aus der Fabrik abrufen (ID -Wert in der Konfigurationsdatei, Polymorphism wird hier verwendet) Userservice usi = (UserService) ac.getbean ("UserService"); // Aufrufen der Methode des Objekts zur Ausführung usi.sayhello (); // ApplicationContext-Implementierungsklasse bietet eine enge Methode, und die Fabrik kann geschlossen werden und die Destory-Method-Methode kann ausgeführt werden. }}Der Unterschied zwischen alten Fabriken und neuen Fabriken
* Unterschied zwischen Beanfactory und ApplicationContext
* Beanfactory - Beanfactory braucht faules Laden, und die Bean wird nur initialisiert, wenn Sie zum ersten Mal in die Tatbean kommen
* ApplicationContext - Wenn Sie applicationContext.xml laden, wird eine bestimmte Instanz des Bean -Objekts erstellt, und einige andere Funktionen werden bereitgestellt.
* Ereignislieferung
* Bean Automatische Montage
* Kontextimplementierungen verschiedener Anwendungsschichten
Zusammenfassung: Dies ist die grundlegendste Demo, die die Implementierungsklasse in der Spring -Konfigurationsdatei konfiguriert. Jedes Mal, wenn der Server gestartet wird, wird die Konfigurationsdatei geladen, wodurch die Implementierungsklasse instanziiert wird.
1. Was ist Abhängigkeitsinjektion?
Feder kann Objekte von J2EE -Anwendungsstufen effektiv organisieren. Unabhängig davon, ob es sich um das Aktionsobjekt der Steuerungsschicht, das Serviceobjekt der Geschäftsschicht oder das DAO -Objekt der Persistenzschicht handelt, kann sie organisch koordiniert und unter Spring's Management ausgeführt werden. Feder organisiert Objekte jeder Schicht locker gekoppelt. Aktionsobjekte müssen sich nicht um die spezifische Implementierung von Serviceobjekten kümmern, Serviceobjekte müssen sich nicht um die spezifische Implementierung persistierter Ebenenobjekte kümmern, und Aufrufe jedes Ebenenobjekts sind vollständig mit der Schnittstelle orientiert. Wenn das System neu ausgerichtet werden muss, wird die Menge des Code -Umschreibens stark reduziert. In der Abhängigkeitsinjektion organisiert die Bean und Bean in Konfigurationsdateien, anstatt festcodiert zu werden. Abhängigkeitsinjektion verstehen
Die Abhängigkeitsinjektion und Kontrolle der Kontrolle sind das gleiche Konzept. Die spezifische Bedeutung lautet: Wenn eine Rolle (möglicherweise eine Java -Instanz, Anrufer) die Unterstützung einer anderen Rolle (eine andere Java -Instanz, Anrufer) benötigt, wird der Anrufer normalerweise vom Anrufer erstellt. Aber im Frühjahr wird die Arbeit des Erstellens der Callee nicht mehr vom Anrufer erledigt, so dass sie als Kontrollinversion bezeichnet wird. Die Arbeit der Erstellung der Callee -Instanz wird normalerweise vom Federbehälter erledigt und dann in den Anrufer injiziert, sodass sie auch als Abhängigkeitsinjektion bezeichnet wird.
Unabhängig davon, ob es sich um eine Abhängigkeitsinjektion oder Kontrollinversion handelt, bedeutet dies, dass der Frühling eine dynamische und flexible Möglichkeit nimmt, verschiedene Objekte zu verwalten. Die spezifischen Implementierungen zwischen Objekten sind zueinander transparent.
2. Das Konzept von IOC und DI
* IOC - Umkehrung der Kontrolle, Kontrolle der Inversion, das Erstellen des Objekts in die Erstellung invertiert! !
* DI - Abhängigkeitsinjektion, Abhängigkeitsinjektion, wenn das Spring -Framework für das Erstellen von Bean -Objekten verantwortlich ist und Abhängigkeitsobjekte in die Bean -Komponente dynamisch injizieren! !
3. Demo
Für Klassenmitgliedvariablen gibt es zwei häufige Injektionsmethoden.
Injektions- und Konstruktor -Methode -Injektion von Eigenschaftssatzmethoden
Demonstrieren Sie zunächst den ersten Typ: Eigenschaftssatzmethodeninjektion
1) Persistente Schicht
Paket com.clj.demo3; öffentliche Klasse CustomerDaOImpl {public void Save () {System.out.println ("Ich bin dao von der Persistenzschicht"); }}2) Geschäftsschicht
Hinweis: Zu diesem Zeitpunkt möchte ich die Persistenzschicht in die Geschäftsschicht einbringen und das Recht übergeben, die Persistenzschichtinstanz in den Rahmen zu erstellen. Die Bedingung ist, dass die Geschäftsschicht die Mitgliedsattribute und festgelegte Methoden der Persistenzschicht bereitstellen muss.
Paket com.clj.demo3;/** * Abhängigkeitsinjektion injiziert die DAO -Ebene in die Serviceschicht. public void setCustomerdao (CustomerDaOImpl CustomerDao) {this.customerdao = customerDao; } public void Save () {System.out.println ("Ich bin der Dienst ..."); // 1. Ursprüngliche Methode // New CustomerDaoImpl (). Save (); //2.spring IOC -Methode CustomerDao.save (); }}3) Konfigurationsdateikonfiguration
<!-Demonstrationsabhängigkeitsinjektion-> <bean id = "customerDao"/> <bean id = "customerservice"> <!-DAO in die Serviceschicht eingeben-> <Property name = "CustomerDao" Ref = "CustomerDao"> </Property> </bean>
4) Test
/** * Springabhängigkeitsinjektionsmethode * DAO -Schicht in die Serviceschicht eingeben CustomerserviceImpl csi = (customerserviceImpl) context.getBean ("Customerservice"); csi.save (); }Der zweite Typ: Konstruktionsmethode -Injektion
1) Pojo -Klasse und Bereitstellung von Konstruktormethoden
Paket com.clj.demo4;/** * Die Demo -Injektionsmethode * @Author Administrator * * */public Class CAR1 {private String cname; privater Doppelpreis; public car1 (String cname, Doppelpreis) {Super (); this.cname = cname; this.price = Preis; } @Override public String toString () {return "car1 [cname =" + cname + ", price =" + price + "]"; }}2) Konfigurationsdateikonfiguration
<!-Demonstrieren Sie die Methode zur Injektion der Konstruktionsmethode-> <bean id = "car1"> <!-Schreiben Sie Methode 1 <Konstruktor-Arg-Name = "cname" value = "bmw"/> <constructor-arg name = "price" value = "400000"/-> <! value = "400000"/> </bean>
3) Test
@Test public void run1 () {applicationContext ac = new classPathXmlApplicationContext ("ApplicationContext.xml"); CAR1 CAR = (CAR1) AC.getbean ("Car1"); System.out.println (Car); }Erweiterung: Das Erstellen der Methode injiziert ein Objekt in ein anderes
1) Pojo -Klasse: Zweck: Injizieren Sie das Auto in die obige Spalte in den Menschen und machen Sie es zu einem der Attribute. In dieser Klasse müssen die Mitgliedattribute des Autos bereitgestellt und parametrisierte Baumethoden bereitgestellt werden.
Paket com.clj.demo4; public class Person {private Zeichenfolge Name; Privat Car1 CAR1; public person (string name, car1 car1) {super (); this.name = name; this.car1 = car1; } @Override public String toString () {return "person [name =" + name + ", car1 =" + car1 + "]"; }}2) Konfigurationsdatei
<!-Constructor-Arg name = "name" value = "jaxiansen"/> <constructor-arg name = "car1" ref = "car1"/> </bean>
V.
1) Definieren Sie die Pojo -Klasse
Paket com.clj.demo4; import Java.util.Arrays; import Java.util.list; import Java.util.map; Import Java.util.Properties; private Liste <string> Liste; private set <string> sets; private map <String, String> Karte; private Eigenschaften Pro; public void setPro (Properties pro) {this.pro = pro; } public void setsets (set <string> sets) {this.sets = sets; } public void setMap (map <String, String> map) {this.map = map; } public void setList (Liste <string> list) {this.list = list; } public void setarrrs (String [] arrrs) {this.arrs = arrrs; } @Override public String toString () {return "user [arrs =" + arrays.toString (arrs) + ", list =" + list + ", sets =" + sets + ", map =" + map + ", pro =" + pro + "]"; }}2) Konfigurationsdatei
<!-Injection Set-> <bean id = "user"> <!-Array-> <Eigenschaft name = "arrs"> <list> <wert> number1 </value> <value> number2 </value> <wert> nummer3 </value> </list> </property> <! </property> <!-- set set--> <property name="sets"> <set> <value>Haha</value> <value>Haha</value> </set> </property> <!-- map set--> <property name="map"> <map> <entry key="aa" value="rainbow"/> <entry key="bb" value="hellowvenus"/> </map> </property> <!-- Property file--> <Eigenschaft name = "pro"> <props> <propet key = "userername"> root </prop> <propt key = "password"> 123 </prop> </props> </property> </bean>
3) Test
/ *** Testen Sie die Injektionssammlung*/ @test public void run3 () {applicationContext ac = new classPhodexMlApplicationContext ("applicationContext.xml"); User user = (user) ac.getbean ("user"); System.out.println (Benutzer); }5. Wie man sich in Modulen entwickelt
Fügen Sie die Hauptkonfigurationsdatei <IMimporte> Tag hinzu (gehen Sie davon aus, dass ein Konfigurationsdatei applicationContext2.xml unter dem Paket com.clj.test definiert ist).
<!-Einführung anderer Konfigurationsdateien nach Modulentwicklung-> <importieren ressourcen = "com/clj/test/applicationContext2.xml"/>
1. Erste Schritte
1) .IMPORT JAR -Paket
Zusätzlich zu den vorherigen 6 Paketen benötigen Sie auch ein Spring-AOP-Paket, um Annotation zu spielen.
2). Persistenzschicht und Implementierungsschicht (Schnittstellen werden hier ignoriert)
Persistente Schicht
Paket com.clj.demo1; import org.springframework.context.annotation UserDao {@Override public void Save () {System.out.println ("den Client speichern .."); }}Geschäftsschicht
Paket com.clj.demo1; import javax.annotation.postconstruct; import org.springframework.bean.factory.Annotation.autowired; org.springframework.stereotype.comPonent; Public Class UserServiceImpl implementiert UserService {@Override public void sayshello () {System.out.println ("Hallo Spring"); }}3). Definieren Sie die Konfigurationsdatei
Zu diesem Zeitpunkt müssen die Einschränkungen Kontextbeschränkungen hinzufügen und Komponentenscanning hinzufügen
<? xmlns: context = "http://www.springframework.org/schema/context" xsi: Schemalocation = "http://www.spingframework.org/schema/beans http://www.springramework.org/schema/beans/ http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-Bean Definitionen hier-> <! Base-Package = "com.clj.demo1"/> </beans>
4) Anmerkungen zur Implementierungsklasse hinzufügen
/*** Komponentenannotation, mit der die aktuelle Klasse* ähnlich wie <bean id = "userService">* Wert bedeutet, einen Alias für die Klasse*/@component (value = "userService") öffentliche Klasse UserServiceImpl -Implementierung UserService {// ausgelöst}} anzugeben5) Tests schreiben
/ *** Annotationsmethode*/ @test public void run2 () {applicationContext ac = new classPhodexMlApplicationContext ("applicationContext.xml"); UserService US = (UserService) ac.getBean ("UserService"); us.sayhello (); }2. Über gemeinsame Attribute des Bean -Managements
1. @Component: Komponente. (Wir haben in der Klasse gehandelt) Die primitivste Annotation ist in Ordnung, dies für alle Klassen zu schreiben, die Annotation benötigen.
2. Im Frühjahr werden drei abgeleitete Anmerkungen von @Component bereitgestellt: (Die Funktionen sind derzeit konsistent)
* @Controller - funktioniert auf der Webschicht
* @Service - Handelt auf Geschäftsebene
* @Repository - Auf der Persistenzschicht handeln
* Hinweis: Diese drei Anmerkungen sollen den Zweck der Annotationsklasse selbst klar machen, und der Frühling verbessert sie in nachfolgenden Versionen.
3. Anmerkungen zur Attributinjektion (Hinweis: Bei Verwendung der Annotationsinjektion müssen Sie keine festgelegte Methode angeben)
* Wenn es sich um eine normale Art der Injektion handelt, können Sie die Wertschettern verwenden
* @Value - zum Injektieren normaler Typen
* Wenn der injizierte Objekttyp, verwenden Sie die folgende Annotation
* @Autowired - Standardmäßig wird der Typ automatisch nach Typ zusammengestellt und hat nichts mit dem Klassennamen der injizierten Klasse zu tun.
* Wenn Sie mit Namen injizieren möchten
* @Qualifier - Erzwungene Verwendung der Namensinjektion muss mit Autoweged verwendet werden, geben Sie den Klassennamen an und beziehen sich auf den injizierten Klassennamen
* @Resource - entspricht @autowired und @Qualifier
* Betonung: Anmerkungen von Java bereitgestellt
* Das Attribut verwendet das Namensattribut
4. Annotation des Bohnenbereichs
* Annotiert als @Scope (Value = "Prototyp"), das in der Klasse verwendet wird. Die Werte sind wie folgt:
* Singleton - Singleton, Standardwert
* Prototyp - mehrere Fälle
5. Konfiguration des Lebenszyklus der Bohne (verstehen)
* Die Annotation ist wie folgt:
* @Postconstruct-entspricht init-Methode
* @Predestroy-gleichwertig, Methode zu zerstören
1. Demonstration der Annotation von Attributobjekten
Bedingung: Inject Attribute (Name) und Object (UserDaOImpl) durch Scannen in die Geschäftsschicht.
1) Öffnen Sie die Persistenzschicht, um die Annotation zu scannen
//@component (value = "userDao") Universal Class Annotation@repository (value = "ud") public class userDaOImpl implementiert UserDao {@Override public void Save () {System.out.println ("Save the client .."); }}2) Die Geschäftsschicht enthält Annotationen für Attribute und Objekte
Paket com.clj.demo1; import javax.annotation.postconstruct; import org.springframework.bean.factory.Annotation.autowired; org.springFramework.stereotype.comPonent;/** * Komponentenannotation kann verwendet werden, um die aktuelle Klasse zu markieren. // Attribut -Annotation: Es ist gleichbedeutend mit der Injektion der angegebenen Zeichenfolge in das Namensattribut. Die SetName -Methode kann ohne Schreiben @Value (value = "jaxiansen") privater String -Name weggelassen werden. /** * Referenzinjektionsmethode 1: autowired () * Referenzinjektionsmethode 2: autowired () + qualifier * Referenzinjektionsmethode 3: @resource (name = "userDao") Java -Methode, identifizieren Sie die Injektion mit Namen * // automatisch () ist automatisch zusammengebaut und mit Typen injiziert (stellverträgt). @Qualifier (value = "ud") // Injektion mit Namen, es muss mit autowirer verwendet werden. Beide können die Klasse private userDao userDao angeben. // Beachten Sie, dass der Wert im Qualifikationsmerkmal der Annotationsname oben im Namen UserDaOImpl -Klasse ist, oder Sie können den ID -Namen der Bean in der Konfigurationsdatei/*public void setName (String -Name) {this.name = name; }*/ @Override public void SayShello () {System.out.println ("Hallo Spring"+Name); userDao.save (); } // @postconstruct Tag Annotation zur Initialisierung in Aktion Lifecycle @Postconstruct public void init () {System.out.println ("initialize ..."); }}3) Die Konfigurationsdatei muss nur aktiviert werden, um alle Konfigurationsdateien zu scannen
<? xmlns: context = "http://www.springframework.org/schema/context" xsi: Schemalocation = "http://www.spingframework.org/schema/beans http://www.springramework.org/schema/beans/ http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-Bean Definitionen hier-> <! Base-Package = "com.clj.demo1"/> </beans>
Hinweis: In Bezug auf Sammlungen wird empfohlen, Konfigurationsdateien zu verwenden
2. Spring Framework integriert JUNIT -Unit -Tests
1) Fügen Sie den erforderlichen Abhängigkeitspaket für Spring-Test.jar hinzu
Hinweis: MyeClipes verfügt über eine eigene JUNIT -Umgebung, aber manchmal aufgrund von Versionsproblemen kann eine neue Jungit -Umgebung erforderlich sein. Hier habe ich ein neues JUNIT-4.9-JAR-Paket online heruntergeladen. Wenn myeclipes neuer ist, müssen Sie es nicht in Betracht ziehen.
2) Schreiben Sie eine Testklasse und fügen Sie entsprechende Anmerkungen hinzu
@Runwith und @ContextConfiguration (mit diesem wird zum Laden der Konfigurationsdatei verwendet, da der Standardpfad von Webroot ein Verzeichnis erster Ebene ist. Außerdem soll festgelegt werden, dass SRC ein Verzeichnis erster Ebene ist).
Paket com.clj.demo2; import javax.annotation.resource; import org.junit.test; import org.junit.runner.runwith; com.clj.demo1.userservice; @runwith (SpringJunit4ClassRunner.class) @ContextConfiguration ("classPath: applicationContext.xml") öffentliche Klasse Demo2 {@Resource (name = "userservice") private userservice; @Test public void run1 () {UserService.sayhello (); }}6. AOP des Frühlingsgerüsts
1.Was ist AOP
* In der Softwareindustrie ist AOP die Abkürzung der Aspekt -orientierten Programmierung, was bedeutet: Facettenprogrammierung, funktionale Modularität
* AOP ist ein Programmierparadigma, das mit der Kategorie der Softarbeiten verbunden ist und Entwicklern zum Organisieren von Programmstrukturen führt
* AOP wurde zuerst von der AOP -Allianzorganisation vorgeschlagen und formulierte eine Reihe von Normen. Spring hat AOP -Ideen in den Rahmen eingeführt und muss die Spezifikationen der AOP -Allianz einhalten.
* Eine Technologie zur Erzielung einer einheitlichen Wartung von Programmfunktionen durch Vorkompilation und dynamische Wirkstoffe während der Laufzeit
* AOP ist eine Fortsetzung von OOP, ein heißes Thema in der Softwareentwicklung, ein wichtiger Bestandteil des Spring -Frameworks und ein Derivatparadigma der funktionalen Programmierung.
* Mit AOP können verschiedene Teile der Geschäftslogik isoliert werden, wodurch die Kopplung zwischen den Teilen der Geschäftslogik reduziert wird, die Wiederverwendbarkeit des Programms verbessert und die Effizienz der Entwicklung verbessert.
AOP nimmt einen horizontalen Extraktionsmechanismus an und ersetzt den sich wiederholenden Code des traditionellen vertikalen Vererbungssystems (Leistungsüberwachung, Transaktionsmanagement, Sicherheitsinspektion, Caching)
2. Warum AOP studieren
* Das Programm kann erweitert werden, ohne den Quellcode zu ändern! ! (Erstellen Sie einen Proxy für eine feste Methode. Bevor Sie auf die Methode zugreifen, geben Sie zuerst den Proxy ein. In den Proxy können Sie mehr Funktionen schreiben, um die Methode leistungsfähiger zu machen und das Programm zu verbessern.)
AOP: Orientierte Programmierung, modularisiert alles, jedes Modul ist relativ unabhängig, Module können gemeinsam genutzt werden (gleich) und unterschiedlich sind besonders angepasst. Verwenden Sie dies anstelle einer herkömmlichen vertikalen Programmierung, um die Wiederverwendbarkeit des Programms zu verbessern
3. AOP -Implementierung (Implementierungsprinzip)
Die Implementierung von AOP enthält zwei Proxy -Methoden <1> zum Implementieren von Klassenschnittstellen: Verwenden Sie JDK Dynamic Proxy <2> keine implementierten Klassenschnittstellen: Verwenden Sie CGLIB Dynamic Proxy
1. Implementieren Sie JDK Dynamic Proxy
1) Definieren Sie die Implementierungsklasse Persistence Layer Interface
Paket com.clj.demo3; public interface userDao {public void Save (); public void update ();} paket com.clj.demo3; public class userDaoImpl implementiert userDao {@Override public void Save () {System.out.println ("Benutzer speichern"); } @Override public void update () {System.out.println ("Benutzer ändern"); }}2) Definieren Sie die JDK Dynamic Proxy Tool -Klasse
Diese Werkzeugklasse fügt einige Funktionen hinzu, wenn die Ausführung der Persistenzschichtsparmethode ausgeführt wird, und in der Entwicklung müssen eine Methode gestärkt werden, ohne den Quellcode zu ändern.
Paket com.clj.demo3; import Java.lang.reflect.invocationHandler; import Java.lang.reflect.method; import Java.lang.reflect.proxy;/** * Generieren proxy -Objekte in jdk (Demonstration von AOP -Prinzipien demonstrieren) * @author administrator * */public class */public class */public class */public class */public class */public class */public class */public class */public class */public class */public klassifon GetProxy (endgültige userdao dao) {// Proxy -Klasse verwenden, um Proxy -Objekte UserDao proxy = (userDao) proxy.newproxyinstance (Dao.GetClass (). Sobald das öffentliche Objekt aufgerufen wird (Objektproxy, Methode, Object [] args) löst Throwable {// Proxy aus, die das aktuelle Proxy -Objekt repräsentiert // Methode, das von den aktuellen Objekten ausgeführt wird // args eingekapselte Parameter // die Klasse speichern oder aktualisieren. return methode.invoke (dao, args); Proxy zurückgeben; }}3) Test
Paket com.clj.demo3; import org.junit.test; public class Demo1 {@test public void run1 () {// das Zielobjekt userDao dao = new UserDaOImpl () erhalten; Dao.Save (); Dao.Update (); System.out.println ("==================================================================================================================== ========================================================ieben Verwenden Sie die Werkzeugklasse, um den Proxy -Objekt -UserDao -Proxy = MyProxyutils.getProxy (DAO) zu erhalten.2. Implementieren Sie die CGGLIB -Technologie
1) Definieren Sie die Persistenzschicht, es gibt zu diesem Zeitpunkt keine Schnittstelle
paket com.clj.demo4; public class bookDaoImpl {public void Save () {System.out.println ("Save Book"); } public void update () {System.out.println ("Buch modifizieren"); }}2) Schreibwerkzeugkurse schreiben
Paket com.clj.demo4; import Java.lang.reflect.method; import org.springframework.cglib.proxy.enhancer; Proxy -Methode * @Author Administrator * * */public class mycglibutils {/** * Proxy -Objekt mit CGGLIB -Methode generieren * @return */public static bookDaOImpl getProxy () {Enhancer Enhancer = New Enhancer (); // Setzen Sie die übergeordnete Klasse Enhancer.setsuperClass (bookdaoImpl.class); // Setzen Sie den Callback -Funktion Enhancer. } return methodProxy.invokesuper (obj, objs); // ist die Methode, die ausgeführt wird}}); // generieren Sie den Proxy -Objekt bookDaoImpl proxy = (bookDaoImpl) Enhancer.create (); Proxy zurückgeben; }}3) Testklassen schreiben
Paket com.clj.demo4; import org.junit.test; public class Demo1 {@test public void run1 () {// Zielobjekt bookdaoImpl dao = new bookDaoImpl (); Dao.Save (); Dao.Update (); System.out.println("==============================); BookDaoImpl proxy=MyCglibUtils.getProxy(); proxy.save(); proxy.update(); }}3. Die AOP -Entwicklung von Spring basierend auf Aspektj (Konfigurationsdateimethode)
1) Stellen Sie die Umgebung ein und importieren Sie das entsprechende JAR -Paket
2) Erstellen Sie Konfigurationsdateien und führen Sie AOP -Einschränkungen ein
<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/aop http://www.sprungramework.org/schema/aop http://www.spingfrapha/aopema/aop http://www.springframework.org/schema/aop/spring-aop.xsd ">
3) Erstellen Sie Schnittstellen und implementieren Sie Klassen
Paket com.clj.demo5; öffentliche Schnittstelle CustomerDao {public void Save (); public void update ();} Paket com.clj.demo5;/** * Verwenden Sie die Konfigurationsdatei, um AOP zu interpretieren System.out.println ("den Kunden speichern"); } @Override public void update () {// Todo automatisch generierte Methode stub system.out.println ("Aktualisiert den Kunden"); }}4) Definieren Sie die Facettenklasse
Paket com.clj.demo5; import org.aspespespectj.lang.proceedingJoInpoint;/** * Facettenklasse: Einstiegspunkt + Benachrichtigung * @Author Administrator * */public class myaSespectXml {/** * Benachrichtigung (spezifische Verbesserung) */public void Log () {System.Out.Println ("Logn (" Log "; } / ** * Die Methode wird erfolgreich ausgeführt, oder Ausnahmen werden nach () {System.out.println ("endgültige Benachrichtigung") ausgeführt. } /*** Nach der Ausführung der Methode wird die Postbenachrichtigung ausgeführt. Wenn im Programm eine Ausnahme auftritt, wird die Postbenachrichtigung nicht ausgeführt */ public void att. } / ** * Nach der Ausführung der Methode wird die Ausnahmebenachrichtigung ausgeführt. } /*** Surround -Benachrichtigung: Die Benachrichtigung wird vor und nach der Ausführung der Methode erstellt. * Standardmäßig kann die Methode des Zielobjekts nicht ausgeführt werden, und das Zielobjekt muss manuell ausgeführt werden */ public void in der Umgebung (Proceedingjoinpoint Joinpoint) {System.out.println ("Wrap -Benachrichtigung 1"); // Die Methode des Zielobjekts manuell ausführen lassen, try {joinspoint.procece (); } catch (throwable e) {// Todo automatisch generierter Block e.printstacktrace (); } System.out.println ("Wrap -Benachrichtigung 2"); }}5) Implementierungsklassen und Facettenklassen injizieren
<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here --> <!-- 配置客户的dao --> <bean id="customerDao"/> <!-- 编写切面类配置好--> <bean id="myAspectXml"/> <!-- 配置AOP --> <aop:config> <!-- 配置切面类:切入点+通知(类型)--> <aop:aspect ref="myAspectXml"> <!-- 配置前置通知，save方法执行之前，增强方法会执行--> <!-- 切入点表达式：execution(public void com.clj.demo5.CustomerDaoImpl.save()) --> <!-- 切入点表达式： 1.execution()固定的，必写2.public可以省略不写3.返回值必写,严格根据切入点方法而定，否则增强方法不会执行，可以用*代替，表示任意的返回值4.包名必写，可以用*代替(如：*..*(默认所有包); com.clj.*) 5.类名必写，可以部分用*(如*DaoImpl表示以'DaoImpl'结尾的持久层实现类),但不建议用*代替整个类名6.方法必写，可以部分用*(如save*表示以'save'开头的方法),但不建议用*代替整个类名7.方法参数根据实际方法而定,可以用'..'表示有0或者多个参数--> <!-- <aop:before method="log" pointcut="execution(public void com.clj.*.CustomerDaoImpl.save(..))"/> --> <aop:before method="log" pointcut="execution(* *..*.*DaoImpl.save*(..))"/> </aop:aspect> </aop:config></beans>
6）测试
package com.clj.demo5;import javax.annotation.Resource;import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext.xml")public class Demo1 { @Resource(name="customerDao") private CustomerDao customerDao; @Test public void run(){ customerDao.save(); customerDao.update(); }}扩展：切面类升级
<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here --> <bean id="myAspectXml"/> <aop:config> <aop:aspect ref="myAspectXml"> <!-- 配置最终通知<aop:after method="after" pointcut="execution(* *..*.*DaoImpl.save*(..))"/>--> <!-- 配置后置通知<aop:after-returning method="afterReturn" pointcut="execution(* *..*.*DaoImpl.save*(..))"/>--> <!-- 配置异常通知<aop:after-throwing method="afterThrowing" pointcut="execution(* *..*.*DaoImpl.save*(..))"/>--> <aop:around method="around" pointcut="execution(* *..*.*DaoImpl.update*(..))"/> </aop:aspect> </aop:config></beans>
4、Spring框架AOP之注解方式
1）创建接口和实现类
package com.clj.demo1;public interface CustomerDao { public void save(); public void update();} package com.clj.demo1;public class CustomerDaoImpl implements CustomerDao{ @Override public void save() { // TODO Auto-generated method stub System.out.println("Save customer.."); } @Override public void update() { // TODO Auto-generated method stub System.out.println("Update customer"); }}2）定义切面类
package com.clj.demo1;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.After;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;import org.aspectj.lang.annotation.Pointcut;/** * 注解方式的切面类* @Aspect表示定义为切面类*/@Aspectpublic class MyAspectAnno { //通知类型：@Before前置通知(切入点的表达式) @Before(value="execution(public * com.clj.demo1.CustomerDaoImpl.save())") public void log(){ System.out.println("记录日志。。"); } //引入切入点@After(value="MyAspectAnno.fun()") public void after(){ System.out.println("执行之后"); } @Around(value="MyAspectAnno.fun()") public void around(ProceedingJoinPoint joinPoint){ System.out.println("环绕通知1"); try { //让目标对象执行joinPoint.proceed(); } catch (Throwable e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("环绕通知2"); } //自定义切入点@Pointcut(value="execution(public * com.clj.demo1.CustomerDaoImpl.save())") public void fun(){ }}3）配置切面类和实现类，并开启自动代理
<?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" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" 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.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- 开启自动注解代理--> <aop:aspectj-autoproxy/> <!-- 配置目标对象--> <bean id="customerDao"/> <!-- 配置切面类--> <bean id="myAspectAnno"/></beans>
spring提供了JDBC模板：JdbcTemplate类
1.快速搭建
1）部署环境
这里在原有的jar包基础上，还要添加关乎jdbc的jar包，这里使用的是mysql驱动
2）配置内置连接池，将连接数据库程序交给框架管理,并配置Jdbc模板类
<?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" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" 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.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- 先配置连接池(内置) --> <bean id="dataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://192.168.174.130:3306/SSH"/> <property name="username" value="root"/> <property name="password" value="root"/> </bean> <!-- 配置JDBC的模板类--> <bean id="jdbcTemplate"> <property name="dataSource" ref="dataSource"/> </bean></beans>
3) Test
package com.clj.demo2;import java.sql.ResultSet;import java.sql.SQLException;import java.util.List;import javax.annotation.Resource;import org.apache.commons.dbcp.BasicDataSource;import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.cglib.beans.BeanMap;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.jdbc.core.RowMapper;import org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;/** * 测试JDBC的模板类，使用IOC的方式* @author Administrator * */@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext.xml")public class Demo2 { @Resource(name="jdbcTemplate") private JdbcTemplate jdbcTemplate; /** * 插入*/ @Test public void run1(){ String sql="insert into t_account values(null,?,?)"; jdbcTemplate.update(sql,"李钇林",10000); } /** * 更新*/ @Test public void run2(){ String sql="update t_account set name=? where id=?"; jdbcTemplate.update(sql,"李钇林",1); } /** * 删除*/ @Test public void run3(){ String sql="delete from t_account where id=?"; jdbcTemplate.update(sql,4); } /** * 测试查询，通过主键来查询一条记录*/ @Test public void run4(){ String sql="select * from t_account where id=?"; Account ac=jdbcTemplate.queryForObject(sql, new BeanMapper(),1); System.out.println(ac); } /** * 查询所有*/ @Test public void run5(){ String sql="select * from t_account"; List<Account> ac=jdbcTemplate.query(sql,new BeanMapper()); System.out.println(ac); }}/** * 定义内部类（手动封装数据（一行一行封装数据，用于查询所有） * @author Administrator * */class BeanMapper implements RowMapper<Account>{ @Override public Account mapRow(ResultSet rs, int rowNum) throws SQLException { Account ac=new Account(); ac.setId(rs.getInt("id")); ac.setName(rs.getString("name")); ac.setMoney(rs.getDouble("money")); return ac; } }2、配置开源连接池
一般现在企业都是用一些主流的连接池，如c3p0和dbcp
首先配置dbcp
1)导入dbcp依赖jar包
2）编写配置文件
<!-- 配置DBCP开源连接池--> <bean id="dataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://192.168.174.130:3306/SSH"/> <property name="username" value="root"/> <property name="password" value="root"/> </bean>
将模板类中引入的内置类datasource改为开源连接池的
3）编写测试类
配置c3p0
1)导入c3p0依赖jar包
2）配置c3p0
<!-- 配置C3P0开源连接池--> <bean id="dataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"/> <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/> <property name="user" value="root"/> <property name="password" value="root"/> </bean>
将模板类中引入的内置类datasource改为开源连接池的
3）编写测试类
1、什么是事务
数据库事务(Database Transaction) ，是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。 事务处理可以确保除非事务性单元内的所有操作都成功完成，否则不会永久更新面向数据的资源。通过将一组相关操作组合为一个要么全部成功要么全部失败的单元，可以简化错误恢复并使应用程序更加可靠。一个逻辑工作单元要成为事务，必须满足所谓的ACID（原子性、一致性、隔离性和持久性）属性。事务是数据库运行中的逻辑工作单位，由DBMS中的事务管理子系统负责事务的处理。
2、怎么解决事务安全性问题
读问题解决，设置数据库隔离级别;写问题解决可以使用悲观锁和乐观锁的方式解决
3、快速开发
方式一：调用模板类，将模板注入持久层
1）编写相对应的持久层和也外层，这里省略接口
package com.clj.demo3;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.jdbc.core.support.JdbcDaoSupport;public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao{ // Method 1: Inject the jdbc template class into the configuration file and write the template class private in the persistence layer JdbcTemplate jdbcTemplate; public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { this.jdbcTemplate = jdbcTemplate; } public void outMoney(String out, double money) { String sql="update t_account set money=money-? where name=?"; jdbcTemplate().update(sql,money,out); } public void inMoney(String in, double money) { String sql="update t_account set money=money+? where name=?"; jdbcTemplate().update(sql,money,in); }} package com.clj.demo4;import org.springframework.transaction.TransactionStatus;import org.springframework.transaction.support.TransactionCallbackWithoutResult;import org.springframework.transaction.support.TransactionTemplate;public class AccountServiceImpl implements AccountService{ //It uses configuration file injection method, and the set method must be provided private AccountDao accountDao; public void setAccountDao(AccountDao accountDao) { this.accountDao = accountDao; } @Override public void pay(String out, String in, double money) { // TODO Auto-generated method stub accountDao.outMoney(out, money); int a=10/0; accountDao.inMoney(in, money); }}2)配置相对应的配置文件
<?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" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" 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.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"><!-- 配置C3P0开源连接池--> <bean id="dataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"/> <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/> <property name="user" value="root"/> <property name="password" value="root"/> </bean><!-- 配置JDBC的模板类--> <bean id="jdbcTemplate"> <property name="dataSource" ref="dataSource"/> </bean><!-- 配置业务层和持久层--> <bean id="accountService"> <property name="accountDao" ref="accountDao"/> </bean><bean id="accountDao"> <!-- 注入模板类--> <property name="jdbcTemplate" ref="jdbcTemplate"/> <property name="dataSource" ref="dataSource"/> </bean></beans>
3)测试类
package com.clj.demo3;import javax.annotation.Resource;import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext.xml")public class Demo1 { @Resource(name="accountService") private AccountService accountService; @Test public void Demo1(){ //Call the payment method accountService.pay("Jia Xiansen","Li Yilin",100); }}方式二：持久层继承JdbcDaoSupport接口，此接口封装了模板类jdbcTemplate
1）编写配置文件
<?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" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" 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.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- 配置C3P0开源连接池--> <bean id="dataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"/> <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/> <property name="user" value="root"/> <property name="password" value="root"/> </bean> <!-- 配置业务层和持久层--> <bean id="accountService"> <property name="accountDao" ref="accountDao"/> </bean> <bean id="accountDao"> <property name="dataSource" ref="dataSource"/> </bean></beans>
2）更改持久层
package com.clj.demo3;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.jdbc.core.support.JdbcDaoSupport;public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao{ //Method 1: Inject the jdbc template class into the configuration file and write the template class directly in the persistence layer// private JdbcTemplate jdbcTemplate;// public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {// this.jdbcTemplate = jdbcTemplate;// } // Method 2: The persistence layer inherits JdbcDaoSupport, which encloses the template class. The persistence layer of the configuration file does not need to inject the template class, nor does it need to configure the template class public void outMoney(String out, double money) { //jdbcTemplate.update(psc); String sql="update t_account set money=money-? where name=?"; this.getJdbcTemplate().update(sql,money,out); } public void inMoney(String in, double money) { String sql="update t_account set money=money+? where name=?"; this.getJdbcTemplate().update(sql,money,in); }}3）更改业务层
package com.clj.demo4;import org.springframework.transaction.TransactionStatus;import org.springframework.transaction.support.TransactionCallbackWithoutResult;import org.springframework.transaction.support.TransactionTemplate;public class AccountServiceImpl implements AccountService{ //It uses configuration file injection method, and the set method must be provided private AccountDao accountDao; public void setAccountDao(AccountDao accountDao) { this.accountDao = accountDao; } @Override public void pay(String out, String in, double money) { // TODO Auto-generated method stub accountDao.outMoney(out, money); int a=10/0; accountDao.inMoney(in, money); }}4)测试类和上述一样
4、spring事务管理
In order to simplify transaction management code, Spring provides a template class TransactionTemplate, which can be manually programmed to manage transactions. You only need to use this template class! !
1、手动编程方式事务(了解原理)
1）快速部署，搭建配置文件,配置事务管理和事务管理模板，并在持久层注入事务管理模板
配置事务管理器
<!-- 配置平台事务管理器--> <bean id="transactionManager"> <property name="dataSource" ref="dataSource"/> </bean>
配置事务管理模板
<bean id="transactionTemplate"> <property name="transactionManager" ref="transactionManager"/></bean>
将管理模板注入业务层
<bean id="accountService"> <property name="accountDao" ref="accountDao"/> <property name="transactionTemplate" ref="transactionTemplate"/></bean>
全部代码：
<?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" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" 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.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- 配置C3P0开源连接池--> <bean id="dataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"/> <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/> <property name="user" value="root"/> <property name="password" value="root"/> </bean> <!-- 配置业务层和持久层--> <bean id="accountService"> <property name="accountDao" ref="accountDao"/> <property name="transactionTemplate" ref="transactionTemplate"/> </bean> <bean id="accountDao"> <property name="dataSource" ref="dataSource"/> </bean> <!-- 配置平台事务管理器--> <bean id="transactionManager"> <property name="dataSource" ref="dataSource"/> </bean> <!-- 手动编码方式，提供了模板类，使用该类管理事务比较简单--> <bean id="transactionTemplate"> <property name="transactionManager" ref="transactionManager"/> </bean></beans>
2）在业务层使用模板事务管理
package com.clj.demo3;import org.springframework.transaction.TransactionStatus;import org.springframework.transaction.support.TransactionCallbackWithoutResult;import org.springframework.transaction.support.TransactionTemplate;public class AccountServiceImpl implements AccountService{ //Usage configuration file injection method, set method must be provided private AccountDao accountDao; //Inject transaction template class private TransactionTemplate transactionTemplate; public void setAccountDao(AccountDao accountDao) { this.accountDao = accountDao; } public void setTransactionTemplate(TransactionTemplate transactionTemplate) { this.transactionTemplate = transactionTemplate; } /** * Method of transfer*/ public void pay(final String out,final String in, final double money) { transactionTemplate.execute(new TransactionCallbackWithoutResult() { //The execution of the transaction, if there is no problem, submit, if Chu Xiang is exception, roll back protected void doInTransactionWithoutResult(TransactionStatus arg0) { // TODO Auto-generated method stub accountDao.outMoney(out, money); int a=10/0; accountDao.inMoney(in, money); } }); }}3）测试类和上一致
package com.clj.demo4;import javax.annotation.Resource;import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext2.xml")public class Demo2 { @Resource(name="accountService") private AccountService accountService; @Test public void Demo1(){ //Call the payment method accountService.pay("Jia Xiansen","Li Yilin",100); }}申明式事务有两种方式：基于AspectJ的XML方式;基于AspectJ的注解方式
1、XML方式
1）配置配置文件
需要配置平台事务管理
<!-- 配置C3P0开源连接池--> <bean id="dataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"/> <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/> <property name="user" value="root"/> <property name="password" value="root"/> </bean> <!-- 配置平台事务管理器--> <bean id="transactionManager"> <property name="dataSource" ref="dataSource"/> </bean>
配置事务增强
<tx:advice id="myAdvice" transaction-manager="transactionManager"> <tx:attributes> <!-- 给方法设置数据库属性（隔离级别，传播行为） --> <!--propagation事务隔离级别：一般采用默认形式：tx:method可以设置多个--> <tx:method name="pay" propagation="REQUIRED"/> </tx:attributes> </tx:advice>
aop切面类
<aop:config> <!-- aop：advisor，是spring框架提供的通知--> <aop:advisor advice-ref="myAdvice" pointcut="execution(public * com.clj.demo4.AccountServiceImpl.pay(..))"/> </aop:config>
Alle Codes
<?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" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" 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.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- 配置C3P0开源连接池--> <bean id="dataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"/> <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/> <property name="user" value="root"/> <property name="password" value="root"/> </bean> <!-- 配置平台事务管理器--> <bean id="transactionManager"> <property name="dataSource" ref="dataSource"/> </bean> <!-- 申明式事务（采用XML文件的方式） --> <!-- 先配置通知--> <tx:advice id="myAdvice" transaction-manager="transactionManager"> <tx:attributes> <!-- 给方法设置数据库属性（隔离级别，传播行为） --> <!--propagation事务隔离级别：一般采用默认形式：tx:method可以设置多个--> <tx:method name="pay" propagation="REQUIRED"/> </tx:attributes> </tx:advice> <!-- 配置AOP:如果是自己编写的AOP,使用aop：aspect配置，使用的是Spring框架提供的通知--> <aop:config> <!-- aop：advisor，是spring框架提供的通知--> <aop:advisor advice-ref="myAdvice" pointcut="execution(public * com.clj.demo4.AccountServiceImpl.pay(..))"/> </aop:config> <!-- 配置业务层和持久层--> <bean id="accountService"> <property name="accountDao" ref="accountDao"/> </bean> <bean id="accountDao"> <property name="dataSource" ref="dataSource"/> </bean></beans>
2）编写持久层和业务层（省略接口）
package com.clj.demo5;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.jdbc.core.support.JdbcDaoSupport;public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao{ //Method 1: Inject the jdbc template class into the configuration file and write the template class directly in the persistence layer// private JdbcTemplate jdbcTemplate;// public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {// this.jdbcTemplate = jdbcTemplate;// } // Method 2: The persistence layer inherits JdbcDaoSupport, which encloses the template class. The persistence layer of the configuration file does not need to inject the template class, nor does it need to configure the template class public void outMoney(String out, double money) { //jdbcTemplate.update(psc); String sql="update t_account set money=money-? where name=?"; this.getJdbcTemplate().update(sql,money,out); } public void inMoney(String in, double money) { String sql="update t_account set money=money+? where name=?"; this.getJdbcTemplate().update(sql,money,in); }} package com.clj.demo5;import org.springframework.transaction.TransactionStatus;import org.springframework.transaction.annotation.Transactional;import org.springframework.transaction.support.TransactionCallbackWithoutResult;import org.springframework.transaction.support.TransactionTemplate;public class AccountServiceImpl implements AccountService{ //It uses configuration file injection method, and the set method must be provided private AccountDao accountDao; public void setAccountDao(AccountDao accountDao) { this.accountDao = accountDao; } @Override public void pay(String out, String in, double money) { // TODO Auto-generated method stub accountDao.outMoney(out, money); int a=10/0; accountDao.inMoney(in, money); }}3）测试类
package com.clj.demo4;import javax.annotation.Resource;import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext2.xml")public class Demo2 { @Resource(name="accountService") private AccountService accountService; @Test public void Demo1(){ //Call the payment method accountService.pay("Jia Xiansen","Li Yilin",100); }}2、注解方式
1）配置配置文件
配置事务管理
<bean id="dataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"/> <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/> <property name="user" value="root"/> <property name="password" value="root"/> </bean> <bean id="transactionManager"> <property name="dataSource" ref="dataSource"/> </bean>
开启注释事务
<!-- 开启事务的注解--> <tx:annotation-driven transaction-manager="transactionManager"/>
Alle Codes
<?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" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" 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.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- 配置C3P0开源连接池--> <bean id="dataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"/> <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/> <property name="user" value="root"/> <property name="password" value="root"/> </bean> <!-- 配置平台事务管理器--> <bean id="transactionManager"> <property name="dataSource" ref="dataSource"/> </bean> <!-- 开启事务的注解--> <tx:annotation-driven transaction-manager="transactionManager"/> <!-- 配置业务层和持久层--> <bean id="accountService"> <property name="accountDao" ref="accountDao"/> </bean> <bean id="accountDao"> <property name="dataSource" ref="dataSource"/> </bean></beans>
2）业务层增加@Transactional
package com.clj.demo5;import org.springframework.transaction.TransactionStatus;import org.springframework.transaction.annotation.Transactional;import org.springframework.transaction.support.TransactionCallbackWithoutResult;import org.springframework.transaction.support.TransactionTemplate;//Add this annotation in the current class means that all the current class has transactions @Transactionalpublic class AccountServiceImpl implements AccountService{ //Using configuration file injection method, the set method must be provided private AccountDao accountDao; public void setAccountDao(AccountDao accountDao) { this.accountDao = accountDao; } @Override public void pay(String out, String in, double money) { // TODO Auto-generated method stub accountDao.outMoney(out, money); int a=10/0; accountDao.inMoney(in, money); }}3）持久层不变
package com.clj.demo5;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.jdbc.core.support.JdbcDaoSupport;public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao{ //Method 1: Inject the jdbc template class into the configuration file and write the template class directly in the persistence layer// private JdbcTemplate jdbcTemplate;// public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {// this.jdbcTemplate = jdbcTemplate;// } // Method 2: The persistence layer inherits JdbcDaoSupport, which encloses the template class. The persistence layer of the configuration file does not need to inject the template class, nor does it need to configure the template class public void outMoney(String out, double money) { //jdbcTemplate.update(psc); String sql="update t_account set money=money-? where name=?"; this.getJdbcTemplate().update(sql,money,out); } public void inMoney(String in, double money) { String sql="update t_account set money=money+? where name=?"; this.getJdbcTemplate().update(sql,money,in); }}4）测试类
package com.clj.demo5;import javax.annotation.Resource;import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext3.xml")public class Demo3 { @Resource(name="accountService") private AccountService accountService; @Test public void Demo1(){ //Call the payment method accountService.pay("Jia Xiansen","Li Yilin",100); }}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.