SSH -Framework -Integration
Vorwort: Einige Leute sagen, dass das Mainstream -Framework jetzt noch beliebt ist und SSM schon lange aus ist, geschweige denn SSH. Ich glaube nicht. Heutzutage verwenden viele Unternehmen immer noch SSH, und wenn sie in Mainstream -Frameworks wechseln, kostet dies. Im Bereich Financial IT IT beispielsweise wird empfohlen, Hibernate in der Datenbankschicht zu verwenden, da es schnell entwickelt werden kann, es sei denn, es handelt sich um das Internet. Da es sich um eine hohe Parallelität handelt, verwendet die Datenbankschicht MyBatis, was eine schnellere Dateninteraktionseffizienz aufweist. Daher kann SSH nicht ignoriert werden.
1. Was ist SSH?
SSH ist ein integriertes Rahmen für Struts+Spring+Hibernate und derzeit ein beliebtes Open -Source -Framework für Webanwendungen.
Das System, das das SSH -Framework integriert, ist hinsichtlich der Verantwortlichkeiten in vier Ebenen unterteilt: Präsentationsschicht, Geschäftslogikschicht, Datenpersistenzschicht und Domänenmodulschicht, damit Entwickler Webanwendungen mit klarer Struktur, guter Wiederverwendbarkeit und kurzfristiger Wartung kurzfristig erstellen können. Unter ihnen wird Struts als Gesamtinfrastruktur des Systems verwendet, die für die Trennung von MVC und im Modellteil des Struts -Frameworks verantwortlich sind und die Geschäftsspringe kontrollieren, wobei das Hibernate -Framework verwendet wird, um die Persistenzschicht zu unterstützen, Frühling verwaltet, verwaltet Strümpfe und Helme. Der spezifische Ansatz lautet: Verwenden Sie objektorientierte Analysemethoden, um einige Modelle entsprechend den Anforderungen vorzuschlagen, diese Modelle als grundlegende Java-Objekte zu implementieren, dann die grundlegende DAO-Schnittstelle (Data Access Objects) zu schreiben und die DAO-Implementierung von Hibernate zu geben. Die von der Hibernate -Architektur implementierte DAO -Klasse wird verwendet, um die Konvertierung und den Zugriff zwischen Java -Klassen und Datenbanken zu realisieren. Schließlich verwaltet und verwaltet Spring Streben und Winterschlaf.
---------- Baidu Encyclopedia
2. Die Teile, die an SSH beteiligt sind
3.. Schnelle Einsatz der Umwelt
Hier verwenden wir eine kleine Demo, um Kunden zu retten, um die Integration von SSH zu demonstrieren
1. Importieren Sie das erforderliche JAR -Paket
1). Struts2 Framework
* Struts-2.3.24/Apps/Struts2-Blank/Web-inf/lib/*. JAR-Alle von Struts2 erforderlichen JAR-Pakete
* Struts2-Spring-Plugin-2.3.24.jar --- Struts2 integriert das Plug-in-Paket von Spring's Plug-in
2). Hibernate Framework
* Hibernate-release-5.0.7.final/lib/required/*.jar-JAR-Paket, das vom Hibernate-Framework erforderlich ist
* SLF4J-API-1.6.1.JAR-Protokollschnittstelle
* SLF4J-Log4J12-1.7.2.jar-Protokollimplementierung
* MySQL-Connector-Java-5.1.7 --in.jar-Mysql Treiberpaket
3). Federgerüst
* IOC -Kernpaket
* AOP -Kernpaket
* JDBC -Vorlagen und Transaktionskernpakete
* Spring integriert JUNIT -Testpaket
* Spring integriert das Kernpaket für das Hibernate
* Spring integriert das Struts2 -Kernpaket
2. Konfigurieren Sie Spring- und Strümpfe -Code in Web.xml
1) Konfigurieren Sie den Struts2 -Kernfilter
Dies ist definiert als alle Abfangen alle
<!-Kernfilter konfigurieren-> <Filter> <Filter-name> Struts2 </filter-name> <filterklasse> org.apache.struts2.dispatcher.ng.filter.strutSpreperAeAndexecuteFilter </filter-class> </Filter> <Filter-Mapping> <Filter-Mapping> </filter-mapping> </filter-mapping> </filter-mapping> </filter-mapping> </filter-mapping> </filter-mapping> </filter-maping <URL-Muster>/*</url-puster> </filtermapping>
2) Konfigurieren Sie den Spring -Hörer
Wenn der Dienst startet, wird die Federkonfigurationsdatei zuerst geladen
<!-Konfigurieren Sie den Listener für das Spring Framework integrieren Web-> <Hörer> <Hörer-Klasse> org.springframework.web.Context.ContextloaderListener </Listener-Klasse> </Listener>
3) Konfigurieren Sie den Standard -Ladepfad
<!-Der Hörer lädt standardmäßig die Web-Inf-Datei. Sie müssen Parameter konfigurieren, um die angegebene Datei zu laden-> <context-Param> <Param-name> contextConFigLocation </param-name> <param-value> classPath: applicationContext.xml </param-value> </context-Param>
Zusammenfassung: Alle Codes für Web.xml sind
<!-Konfigurieren Sie den Listener, der das Web in das Spring Framework integriert-> <Hörer> <Hörer-Klasse> org.springframework.web.Context.ContextloaderListener </Listener-Klasse> </Listener> <! <Param-name> contextConfigLocation </param-name> <param-value> classPath: applicationContext.xml </param-value> </context-param> <!-Konfigurieren Sie Kernfilter-> <filter> <filter-name> Struts2 </filter-name> <Filterklasse> org.apache.struts2.dispatcher.ng.filter.strutsprepareAndexecuteFilter </Filter-Class> </filter> <Filter-Mapping> <Filter-name> Struts2 </filter-name> <URL-PATTER>/*</url-puffer>
2. Schreiben Sie relevante Konfigurationsdateien unter SRC
1) Spring: applicationContext.xml
Import verwandte Einschränkungen
<? xmlns: context = "http://www.springframework.org/schema/context" xmlns: aop = "http://www.spingframework.org/schwa XSI: Schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/contex http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.g/schema/aop/sping/sping-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd "> </Beans>
2) Hibernate: hibernate.cfg.xml
Importieren Sie relevante Einschränkungen und konfigurieren Sie die Datenbank
<? <Session-Factory> <!-Muss konfigurieren-> <Eigenschaft name = "hibernate.connection.driver_class"> com.mysql.jdbc.driver </Property> <Eigentum name = "hibernate.connection.url"> jdbc: MySQL: //192.168.174.130: 3306/SSH </STOMBOLE <//192.168.174.130: 3306/s name = "hibernate.connection.username"> root </property> <Eigenschaft name = "hibernate.connection.Password"> root </Property> <Eigenschaft name = "hibernate.dialect"> org.hiberNate.dialect name = "hibernate.format_sql"> true </property> <Eigenschaft name = "hibernate.hbm2ddl.auto"> update </property> <!-Konfigurieren Sie den Verbindungspool für c3p0-> <Eigenschaft name -> <!-Mapping-Konfigurationsdatei-> <Mapping Resource = "com/clj/domain/customer.hbm.xml"/> </Session-Factory> </hibernate-Configuration>
3) Konfigurieren Sie log4j.properties
### 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) Struts2: Struts.xml
Import verwandte Einschränkungen
<?
Zusammenfassung: Die von SRC benötigte Konfigurationsdatei ist in der Abbildung dargestellt
3. Konfigurieren Sie die DAO -Ebene
Definieren Sie eine Schnittstelle und ihre Implementierungsklasse
public interface customerDao {public void Save (Kunde Kunde);} öffentliche Klasse CustomerDaOImpl implementiert CustomerDao {public void save (Kundenkunde) {}}4. Definieren Sie die Schnittstelle und Implementierungsklasse für Geschäftsschicht
Paket com.clj.service; import com.clj.domain.customer; public interface customerservice {public void save (Kundenkunde);}Paket com.clj.service; import org.springframework.transaction.annotation.transactional; import com.clj.dao.customerdao; com.clj.domain }}
5. Definieren Sie die Pojo -Klasse
Hibernate betreibt Datenbanktabellen, indem sie Pojo-Klassen bedienen, um Objektrelationszuordnungen zu erreichen
Paket com.clj.domain; öffentliche Klasse Kunde {private long Cust_id; private Zeichenfolge Cust_Name; private long Cust_user_id; private long Cust_create_id; private Zeichenfolge Cust_Source; private String Cust_industry; private Zeichenfolge Cust_Level; private Zeichenfolge Cust_linkman; private Zeichenfolge Cust_phone; private Zeichenfolge Cust_Mobile; public long getCust_id () {return Cust_id; } public void setcust_id (lang Cust_id) {this.cust_id = cust_id; } public String getCust_name () {return Cust_name; } public void setCust_name (String Cust_name) {this.cust_name = cust_name; } public long getcust_user_id () {return Cust_user_id; } public void setcust_user_id (long Cust_user_id) {this.cust_user_id = cust_user_id; } public long getcust_create_id () {return cust_create_id; } public void setcust_create_id (long Cust_create_id) {this.cust_create_id = cust_create_id; } public String getCust_Source () {return Cust_Source; } public void setCust_Source (String Cust_Source) {this.cust_source = cust_source; } public String getCust_industry () {return Cust_industry; } public void setCust_industry (String cust_industry) {this.cust_industry = cust_industry; } public String getCust_level () {return Cust_level; } public void setcust_level (String Cust_level) {this.cust_level = cust_level; } public String getCust_linkman () {return Cust_linkman; } public void setcust_linkman (String Cust_linkman) {this.cust_linkman = cust_linkman; } public String getCust_phone () {return Cust_phone; } public void setCust_phone (String Cust_phone) {this.cust_phone = cust_phone; } public String getCust_mobile () {return Cust_Mobile; } public void setCust_mobile (String Cust_mobile) {this.cust_mobile = cust_mobile; } @Override public String toString () {return "customer [cust_id =" + cust_id + ", cust_name =" + cust_name + ", cust_user_id =" + cust_user_id + ", cust_create_id =" + cust_create_id_idsource Cust_level = " + cust_level +", Cust_linkman = " + cust_linkman +", Cust_phone = " + cust_phone +", cust_mobile = " + cust_mobile +"] "; }}6. Kunden definieren.hbm.xml
Diese Konfigurationsdatei bezieht sich auf die Kundenpojo -Klasse. Diese Datei muss unter dasselbe Paket wie die Customer Pojo -Klasse gestellt werden
<? name = "com.clj.domain.customer" table = "cst_customer"> <id name = "cust_id" column = "cust_id"> <generator/> </id> <Eigentum name = "Cust_name" column = "Cust_name"/> <Property name = "cust_user_create" contal = "const", "CustRe_ID"/> < column = "cust_create_id"/> <Eigentum name = "cust_source" column = "cust_source"/> <Eigentum name = "Cust_industry" column = "Cust_industry"/> <Eigentum name = "Cust_level" column = "cust_level"/> <Property nust_linkMan "Cust_LinkMan". name = "cust_phone" column = "cust_phone"/> <Property name = "cust_mobile" column = "cust_mobile"/> </class> </hibernate-mapping>
Projektkonstruktionsdiagramm
4. Vorläufung der Demo zur Erhaltung der Kunden
Hier definieren wir zunächst die Persistenzschicht für Heizerate, die Geschäftsschicht zu Struts2 und die Erstellungsinstanz zum Frühling
1. Definieren Sie eine Schnittstelle, um Kunden zu retten und Formulare zum Senden von Daten zu verwenden
Nach dem Domainnamen können wir sehen, dass die Wildcard -Methode von Struts2 für den Zugriff verwendet wird.
<Form id = Form1 name = Form1 action = "$ {pageContext.request.contextPath} /customer_add.Action" method = post> <!-Tabelle Teil ausgelöst-> </Form>2. Konfigurieren Sie Akzeptanzanforderungen in Struts.xml, springen Sie zur angegebenen Aktion gemäß dem Aktionsnamen und der Methode und führen Sie die angegebene Methode aus
Spring integriert die Struts2 -Methode 1: Aktion wird durch Struts2 Framework verwaltet
* Da das importierte Struts2-Spring-Plugin-2.3.24.jar Paket mit einer Konfigurationsdatei Struts-Plugin.xml enthält, ist der folgende Code in der Konfigurationsdatei enthalten
* <Constant name = "structs.ObjectFactory" value = "fing" /> Einschalten eine Konstante. Wenn die Konstante eingeschaltet wird, kann die folgende Konstante verwendet werden
* Struts.ObjectFactory.spring.autowire = Name, diese Konstante ist eine Klasse, mit der Aktion automatisch Bean -Objekte zusammenstellen kann!
<? Extends = "Struts-Default" Namespace = "/"> <!-Konfigurieren Sie die Kundenaktion-> <!-Methode 1: Aciton wird durch Struts2 Framework-> <actionname = "customer_*" method = "{1}"/> </paket> </struts> verwaltet3. Konfigurieren Sie die entsprechenden Bohnen und Transaktionen in Spring ApplicationContext.xml
Hier wird die Aufgabe des Erstellens einer Instanz an das Spring Framework Management übergeben
<bean id = "customerservice"> <Property name = "customerDao" ref = "customerDao"> </property> </bean> <bean id = "customerDao"> <Property name = "hibernatetemplate" Ref = "Hibernatetemplate"/> </bean> <bean id = hibernatetemplate "<! name = "sessionFactory"/> </bean> </beans>
4. Schreiben Sie Persistenzschicht -Implementierungsklassenbezogener Code
Hier wird die von Hibernate bereitgestellte Vorlagenklasse verwendet, um die Sitzung intern einzuschließen, damit die Methode in der Sitzung aufgerufen werden kann.
/** * Persistenzschicht * * @Author Administrator * */öffentliche Klasse CustomerDaOImpl implementiert CustomerDao {// Daten in der Datenbank speichern (Call -Vorlageklasse (von Hibernate, eingekapselte Sitzung intern)) private hibernatetemplate hibernatetemplate; public void sethibernatetemplate (Hibernatetemplate Hibernatetemplate) {this.hibernatetemplate = hibernatetemplate; } / *** Kunden speichern* / public void speichern (Kundenkunde) {System.out.println ("Permanent Layer: Save Customer"); hibernatetemplate (). Speichern (Kunde); }}5. Schreibgeschäftsschicht -Implementierungsklassenbezogener Code
package com.clj.service;import org.springframework.transaction.annotation.Transactional;import com.clj.dao.CustomerDao;import com.clj.domain.Customer;/** * Customer's business layer* @author Administrator * */@Transactionalpublic class CustomerServiceImpl implements CustomerService{ private CustomerDao customerDao; public void setCustomerdao (CustomerDao CustomerDao) {this.customerdao = customerDao; } // zum Speichern des Kunden public void speichern (Kundenkunde) {System.out.println ("Geschäftsschicht, den Kunden speichern"); CustomerDao.save (Kunden); }}6. Aktionsbezogene Code schreiben
Hier ist die Vorlagenklasse von Struts2
Paket com.clj.web.action; import org.apache.struts2.servletactactacontext; import org.springframework.web.context.WebApplicationContext; com.clj.service.customerservice; import com.opensymphony.xwork2.actionsupport; com.opensymphony.xwork2.modelDiven;/** * Kundenkontrollschicht * @Author Administrator * * */öffentliche Klassenkunde erweitert Aktiengeschäfte implements modelldelen <// // nicht vergessen, manuell neue Kunden zu kundenstunden zu kunden. öffentlicher Kunde getModel () {Return Customer; } // Servicemitglied -Attribute bereitstellen und set method private customerservice customerservice bereitet; public void setCustomerService (Customerservice Customerservice) {this.CustomerService = Customerservice; } / *** Speichern Sie den Kunden* @return* / public String add () {System.out.println ("Webschicht, den Kunden speichern"); // Methode 1: Erstellen Sie die Webfabrik (Aktion wird durch struts2 erstellt) WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext (ServletActionContext.getServletContext ()); Customerservice cs = (customerservice) context.getBean ("customerservice"); // Methode Cs.Save (Kunde) aufrufen; keine zurückgeben; }}5. Integration der Projektoptimierung
1. Spring Integration Struts2 Methode 2: Aktion wird nach Spring Framework verwaltet
Fügen Sie die spezifische Aktionsklassenkonfigurationsdatei ApplicatonContext.xml in die Konfigurationsdatei ein. Hinweis: Struts.xml muss geändert werden
<Struts> <!-Paketstruktur konfigurieren-> <Package name = "crm" extends = "struts-default" namespace = "/"> <!-Konfigurieren Sie die Aktion des Kunden-> <!-Methode 1: Aciton wird durch Struts2-Framework <Action name = "customer_*" method = "{1} verwaltet. Bean ist für das Klassen-Tag erforderlich-> <Action name = "customer_*" method = "{1}"> </action> </package> </struts>2. Konfigurieren Sie die Aktionsklasse in applicationContext.xml
Hinweis: 1) Das Spring Framework generiert standardmäßig eine Kundenaktion, während das Struts2 -Framework mehrfach ist. Sie müssen also Scope = "Prototyp" konfigurieren
2) Zu diesem Zeitpunkt gibt es keine automatische Montage von Struts2. In Aktion müssen Sie die Customerservice -Eigenschaft manuell konfigurieren und die festgelegte Methode in Aktionsklasse generieren.
<!-Konfigurieren Sie das Kundenmodul-> <!-Betont: Der konfigurierte Aciton muss Multi-Säulen-> <bean id = "customerAction" scope = "prototyp"> <!-Hinweis: Wenn Struts Aktionen verwalten, basierend auf einem Streben-Plugin-Jar-Paket, der sich konstant ändert. Sie müssen nur eine festgelegte Methode bereitstellen. Die Aktion wird jedoch nach Frühling verwaltet und die automatische Montage ist ungültig. Daher müssen Sie die Konfigurationseinspritzung manuell durchführen-> <Eigentumsname = "Customerservice" Ref = "Customerservice"> </Property> </bean>
3. Konfigurieren Sie Transaktionen
Spring integriert die Hibernate -Methode eins: (Konfigurationsdatei mit hibernate.cfg.xml. Hervorhebung: Die Konfiguration, die den aktuellen Thread bindet, kann nicht hinzugefügt werden)
In der Vergangenheit wurde Hibernate.cfg.xml beim Hibernate vom Hibernate -Framework verwaltet. Die Konfigurationsdatei kann SessionFactory generieren. Die Persistenzschicht lädt diese Konfigurationsdatei, um SessionFactory zu erhalten, wodurch eine fabrik generierte Sitzung erstellt wird, die Daten hinzugefügt, gelöscht und geändert wird. Zu diesem Zeitpunkt sollte die Konfigurationsdatei an das Spring Management übergeben werden, wodurch die IOC -Eigenschaften von Spring voll ausgewechselt werden.
Das Spring Framework bietet eine Hibernatedaosupport -Werkzeugklasse, die in Zukunft von DAO geerbt werden kann! ! Vor der Einführung der Hibernate -Core -Konfigurationsdatei muss die DAO -Ebene eine übergeordnete Klasse Hibernatedaosupport erben, die die Transaktionsvorlage intern zusammenfasst.
Siehe den Quellcode:
1) Ändern Sie die entsprechende Klasse für Persistenzschicht -Implementierungsklasse und lassen Sie sie hibernatedaosupport erben
Paket com.clj.dao; import org.springframework.orm.hibernate5.hibernatetemplate; import org.springframework.orm.hibernate5.Support.hibernatedaOsupport; Import Com.Clj.domain.customer; @Author Administrator * * * /Public Class CustomerDaOImpl erweitert HibernatedaOsupport implementiert CustomerDao {// Die Daten in der Datenbank speichern (rufen Sie die Vorlagenklasse (bereitgestellt von Hibernate, eingekapselte Sitzung)) / *private hibernatetemplate hibertematetemplate; public void sethibernatetemplate (Hibernatetemplate Hibernatetemplate) {this.hibernatetemplate = hibernatetemplate; }*// ***Speichern Sie den Kunden*/ public void speichern (Kundenkunde) {System.out.println ("Permanent Layer: Save the Customer"); this.gethiberNatetemplate (). Speichern (Kunde); }}2) Ändern Sie die Geschäftsschicht und aktivieren Sie Transaktionsanmerkungen
package com.clj.service;import org.springframework.transaction.annotation.Transactional;import com.clj.dao.CustomerDao;import com.clj.domain.Customer;/** * Customer's business layer* @author Administrator * */@Transactionalpublic class CustomerServiceImpl implements CustomerService{ private CustomerDao customerDao; public void setCustomerdao (CustomerDao CustomerDao) {this.customerdao = customerDao; } // zum Speichern des Kunden public void save (Kundenkunde) {System.out.println ("Geschäftsschicht, den Kunden speichern"); CustomerDao.save (Kunden); }}3) Ändern Sie die Datei applicationContext.xml
Stellen Sie zuerst die Konfigurationsdatei zur Hibernate -Konfiguration ein
<!-Schreiben Sie Beans, die Namen werden behoben, die von Spring bereitgestellt werden, um die Konfigurationsdatei von hibernate zu laden value = "classPath: hibernate.cfg.xml"/> </bean>
Konfigurieren von Plattform -Transaktionsmanagement: Verwendet zum Verwalten von Transaktionen. Beachten Sie, dass das Hibernate -Framework jetzt verwendet wird, sodass der Transaktionsmanager des Hibernate -Frameworks benötigt wird.
<!-konfigurieren
Offene Transaktionsannotation
<!-Annotation zur Aktivierung der Transaktion-> <tx: Annotationsgetriebene Transaktionsmanager = "TransactionManager"/>
Entfernen Sie die Konfiguration der Vorlagenklassen und konfigurieren Sie SessionFactory for Persistenzschicht
<!-In Zukunft muss DAO Hibernatedaosupport erben und SessionFactory-> <bean id = "CustomerDao"> <!-<Property name = "hibernatetemplate" ref = "hibernatetemplate"/> <! Ref = "SessionFactory"/> </bean>
Alle Codes sind wie folgt
<? xmlns: context = "http://www.springframework.org/schema/context" xmlns: aop = "http://www.spingframework.org/schwa XSI: Schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/contex http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.g/schema/aop/sping/sping-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd "> <!-Schreiben Sie Beans, die Namen werden festgelegt, um die Konfigurationsdatei von Hibernate.cfg.xml zu laden. <!-Konfigurationspfad: Wenn der Server gestartet wird, wird das Objekt erstellt, wodurch die Datei hibernate.cfg.xml geladen wird, wodurch das SessionFactory-Objekt-> <Eigenschaft name = "configLocation" value = "ClassPath: hibernate.cfg.xml"/> </> </ban> <!-Konfigurieren Sie die Plattform-Transaktions-Transaktions-Transaction-transaktions-transaction-transaction-transaction-transaction-erster- Die Sitzung kann Transaktionen verwalten, und die Fabrik kann eine Sitzung erstellen-> <Eigenschaft name = "sessionfactory" ref = "sessionfactory"/> </bean> <!-Annotation zur Aktivierung von Transaktionen-> <tx: Annotationsbetriebene Transaktionsmanager = "Transaktionsmanager"/> <!-Konfigurieren Sie Kundenmodule-> <! ID = "CustomerAction" Scope = "Prototyp"> <!-Hinweis: Wenn Struts Aktionen verwaltet, basierend auf einem JAR-Paket mit Struts-Plugin, einer konstanten Strebens.ObjectFactory.spring.autowire = Name wird geändert, um es einzuschalten, und es kann automatisch zusammengestellt werden. Sie müssen nur eine festgelegte Methode bereitstellen. Die Aktion wird jedoch nach Frühling verwaltet und die automatische Montage ist ungültig. Daher müssen Sie die Konfigurationsinjektion manuell durchführen-> <Eigentumsname = "Customerservice" Ref = "Customerservice"> </property> </bean> <bean id = "Customerservice"> <Property name = "Customerdao" Refledaooo> </property> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean; name = "hibernatetemplate" ref = "hibernatetemplate"/>-> <! Layer erbt Hibernatedaosupport, es muss nicht konfiguriert werden-> <!-<bean id = "hibernatetemplate"> inject SessionFactory <Eigenschaft name = "sessionfactory"/> </bean>-> </beans>
4) Ändern Sie die Aktionsklasse
Da die Business Layer -Implementierungsklasse injiziert wird, kann die Geschäftsschichtmethode zu diesem Zeitpunkt direkt aufgerufen werden, ohne die Bean zu laden
Paket com.clj.web.action; import org.apache.struts2.servletactactacontext; import org.springframework.web.context.WebApplicationContext; com.clj.service.customerservice; import com.opensymphony.xwork2.actionsupport; com.opensymphony.xwork2.modelDiven;/** * Kundenkontrollschicht * @Author Administrator * * */öffentliche Klassenkunde erweitert Aktiengeschäfte implements modelldelen <// // nicht vergessen, manuell neue Kunden zu kundenstunden zu kunden. öffentlicher Kunde getModel () {Return Customer; } // Servicemitglied -Attribute bereitstellen und set method private customerservice customerservice bereitet; public void setCustomerService (Customerservice Customerservice) {this.CustomerService = Customerservice; } / *** Speichern Sie den Kunden* @return* / public String add () {System.out.println ("Webschicht, den Kunden speichern"); // Methode 1: Erstellen Sie die Webfabrik (Aktion wird durch struts2 erstellt) /*WebApplicationContext context = webapplicationContextutils.getWebApplicationContext (ServletActActionContext.getServletContext ()); Customerservice cs = (customerservice) context.getBean ("customerservice"); // Methode Cs.Save (Kunde) aufrufen; */ customerservice.save (Kunde); keine zurückgeben; }}Feder Integration Hibernate Methode zwei: (Konfigurationsdatei ohne Hibernate.cfg.xml)
Hier löschen wir die Kernkonfigurationsdatei von Hibernate. Vor dem Löschen müssen Sie den relevanten Inhalt in seiner Konfigurationsdatei in der ApplicationIncontext.xml -Datei von Spring konfigurieren, um ihn zu erhalten.
1. Überprüfen Sie den relevanten Inhalt in der Datei hibernate.cfg.xml
* Grundlegende Parameter der Datenbankverbindung (4 Hauptparameter)
* Hibernate-bezogene Eigenschaften
* Verbindungspool
* Kartendateien
2. Konfiguration einführen
Verbindungspool einführen
<!-Konfigurieren Sie den Verbindungspool für C3P0 First-> <bean id = "dataSource"> <Eigenschaft name = "triverclass" value = "com.mysql.jdbc.driver value = "root"/> <Eigenschaft name = "password" value = "root"/> </bean>
Ändern Sie die entsprechende Sitzungsfaktorik: Da es keine Konfigurationsdatei für hibernate.cfg.xml gibt, müssen Sie die Konfiguration ändern und den Verbindungspool injizieren.
Einführung der Objektzuordnungsdatei: Da die Konfigurationsdatei von hibernate.cfg.xml nicht mehr gescannt ist und die Konfigurationsdatei injiziert werden muss.
<!-Schreiben Sie Beans, die Namen werden festgelegt und werden per Spring zur Verfügung gestellt, um die Konfigurationsdatei von hibernate zu laden key = "hibernate.dialect"> org.hibernate.dialect <!-Mapping-Konfigurationsdateien einführen-> <Eigenschaft name = "mapingResources"> <list> <wert> com/clj/domain/customer.hbm.xml </value> </list> </property> </bean>
Jetzt: Der Code von ApplicationContext.xml ist wie folgt
<? xmlns: context = "http://www.springframework.org/schema/context" xmlns: aop = "http://www.spingframework.org/schwa XSI: Schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/contex http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.g/schema/aop/sping/sping-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd "> <!-Konfigurieren Sie den Verbindungspool für C3P0 First-> <bean id =" DataSource "> < value = "com.mysql.jdbc.driver"/> <Eigenschaft name = "jdbcurl" value = "jdbc: mysql: //192.168.174.130: 3306/ssh"/> <Eigenschaft name = "Benutzer" value = "root"/> <'. spring to load the configuration file of hibernate.cfg.xml--> <bean id="sessionFactory"> <!-- Load the connection pool first-> <property name="dataSource" ref="dataSource"/> <!-- Load dialect, load options--> <property name="hibernateProperties"> <props> <prop key = "hibernate.dialect"> org.hibernate.dialect <!-Injizieren Sie die Mapping-Konfigurationsdatei-> <Eigenschaft name = "mapPingResources"> <list> <wert> com/clj/domain/customer.hbm.xml </value> </list> </property> </bean> <!-Konfigurieren Sie die Plattform-Transaktionsmanager-Erst-> <bean id = "transactionManits. <Eigenschaft name = "sessionfactory" ref = "sessionFactory"/> </bean> <!-Annotation zum Öffnen von Transaktionsmanager = "TransactionManager"/> <!-Konfigurieren Sie das Kundenmodul-> <! Struts-Plugin, ein konstantes Streben. Sie müssen nur die festgelegte Methode bereitstellen. However, the action is managed by spring and the automatic assembly is invalid, so you need to manually perform configuration injection--> <property name="customerService" ref="customerService"></property> </bean> <bean id="customerService"> <property name="customerDao" ref="customerDao"></property> </bean> <!-- In the future, Dao needs to inherit HibernateDaoSupport and inject sessionFactory --> <bean id="customerDao"> <!--<property name="hibernateTemplate" ref="hibernateTemplate"/> -> <!-- The template class is not injected here, but sessionFactory, because the template needs session (encapsulated session)--> <property name="sessionFactory" ref="sessionFactory"/> </bean> <!-- Configure the template class (provided by the hibernate framework, encapsulated session) and is handed over to spring management at this time. If the persistence layer inherits HibernateDaoSupport, there is no need to configure --> <!-- <bean id="hibernateTemplate"> Inject sessionFactory <property name="sessionFactory"/> </bean>--></beans>
此时可以安心的删除hibernate.cfg.xml文件了
这样SSH整合完毕
六、Hibernate模板常用方法
注意：以下代码省略了接口中的演示(偷了个懒，相信初学者不会看不懂)
1）插入：
Persistente Schicht
package com.clj.dao;import java.util.List;import org.hibernate.criterion.DetachedCriteria;import org.springframework.orm.hibernate5.HibernateTemplate;import org.springframework.orm.hibernate5.support.HibernateDaoSupport;import com.clj.domain.Customer;/** * Persistence layer* Inherits HibernateDaoSupport and encapsulates HibernateTemplate internally * @author Administrator * */public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao { @Override public void update(Customer customer) { // TODO Auto-generated method stub this.getHibernateTemplate().update(customer); }}业务层
package com.clj.service;import java.util.List;import org.springframework.transaction.annotation.Transactional;import com.clj.dao.CustomerDao;import com.clj.domain.Customer;/** * Customer's business layer* @author Administrator * */@Transactionalpublic class CustomerServiceImpl implements CustomerService{ private CustomerDao customerDao; public void setCustomerDao(CustomerDao customerDao) { this.customerDao = customerDao; } @Override public void update(Customer customer) { // TODO Auto-generated method stub customerDao.update(customer); }}测试类
package com.clj.test;import java.util.List;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;import com.clj.domain.Customer;import com.clj.service.CustomerService;/** * Simple way to test Hiberante template class* @author Administrator * */@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext.xml")public class Demo1 { @Resource(name="customerService") private CustomerService customerService; /** * Test insert*/ @Test public void run1(){ Customer customer=new Customer(); customer.setCust_id(1L); customer.setCust_name("test"); customerService.update(customer); }}2）以下为指定查询、查询所有、离线查询代码
Persistente Schicht
package com.clj.dao;import java.util.List;import org.hibernate.criterion.DetachedCriteria;import org.springframework.orm.hibernate5.HibernateTemplate;import org.springframework.orm.hibernate5.support.HibernateDaoSupport;import com.clj.domain.Customer;/** * Persistence layer* Inherits HibernateDaoSupport and encapsulates HibernateTemplate internally * @author Administrator * */public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao { //Save data to the database (call template class (provided by hibernate, encapsulated session)) /*private HibernateTemplate hibernateTemplate; public void setHibernateTemplate(HibernateTemplate hibernateTemplate) { this.hibernateTemplate = hibernateTemplate; }*/ /** * Save customer*/ public void save(Customer customer) { System.out.println("Permanent layer: save customer"); this.getHibernateTemplate().save(customer); } @Override public void update(Customer customer) { // TODO Auto-generated method stub this.getHibernateTemplate().update(customer); } /** * Query by primary key*/ public Customer getById(Long id) { return this.getHibernateTemplate().get(Customer.class, id); } /** * Query all*/ @Override public List<Customer> findAll() { String sql="from Customer"; List<Customer> list=(List<Customer>) this.getHibernateTemplate().find(sql); return list; } /** * QBC offline query*/ @Override public List<Customer> findAllByQBC() { DetachedCriteria criteria=DetachedCriteria.forClass(Customer.class); List<Customer> list=(List<Customer>) this.getHibernateTemplate().findByCriteria(criteria); return list; }}业务层
package com.clj.service;import java.util.List;import org.springframework.transaction.annotation.Transactional;import com.clj.dao.CustomerDao;import com.clj.domain.Customer;/** * Customer's business layer* @author Administrator * */@Transactionalpublic class CustomerServiceImpl implements CustomerService{ private CustomerDao customerDao; public void setCustomerDao(CustomerDao customerDao) { this.customerDao = customerDao; } // Used to save customers public void save(Customer customer) { System.out.println("Business layer, save customer"); customerDao.save(customer); } @Override public void update(Customer customer) { // TODO Auto-generated method stub customerDao.update(customer); } @Override public Customer getById(Long id) { // TODO Auto-generated method stub return customerDao.getById(id); } @Override public List<Customer> findAll() { return customerDao.findAll(); } @Override public List<Customer> findAllByQBC() { // TODO Auto-generated method stub return customerDao.findAllByQBC(); }}测试类
package com.clj.test;import java.util.List;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;import com.clj.domain.Customer;import com.clj.service.CustomerService;/** * Simple way to test Hiberante template class* @author Administrator * */@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext.xml")public class Demo1 { @Resource(name="customerService") private CustomerService customerService; /** * Test insert*/ @Test public void run1(){ Customer customer=new Customer(); customer.setCust_id(1L); customer.setCust_name("test"); customerService.update(customer); } /** * Test query the specified customer*/ @Test public void run2(){ Customer customer=customerService.getById(2L); System.out.println(customer); } /** * Query all customers*/ @Test public void run3(){ List<Customer> list=customerService.findAll(); System.out.println(list); } /** * QBC(offline query) */ @Test public void run4(){ List<Customer> list=customerService.findAllByQBC(); System.out.println(list); }}七、关于SSH延迟加载问题
1. 使用延迟加载的时候，再WEB层查询对象的时候程序会抛出异常！
* 原因是延迟加载还没有发生SQL语句，在业务层session对象就已经销毁了，所以查询到的JavaBean对象已经变成了托管态对象！
* 注意：一定要先删除javassist-3.11.0.GA.jar包（jar包冲突了）
2. Lösung
Spring框架提供了一个过滤器，让session对象在WEB层就创建，在WEB层销毁。只需要配置该过滤器即可
* 但是：要注意需要在struts2的核心过滤器之前进行，spring监听器之后配置
<!-- 解决延迟加载的问题--> <filter> <filter-name>OpenSessionInViewFilter</filter-name> <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class> </filter> <filter-mapping> <filter-name>OpenSessionInViewFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
3、演示延迟加载
持久层：调用load方法，此方法时延迟加载的
/** * Lazy load*/ @Override public Customer loadById(long id) { // TODO Auto-generated method stub return this.getHibernateTemplate().load(Customer.class, id); }业务层
@Override public Customer loadById(long id) { // TODO Auto-generated method stub return customerDao.loadById(id); }测试类
@Test public void run5(){ Customer customer=customerService.loadById(2L); System.out.println(customer); }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.