Intégration du cadre SSH
Préface: Certaines personnes disent que le cadre grand public est toujours populaire maintenant, et SSM est sorti depuis longtemps, sans parler de SSH. Je ne pense pas. De nos jours, de nombreuses entreprises utilisent toujours SSH, et si elles changent dans les cadres traditionnels, cela coûtera. Par exemple, dans le domaine informatique financière, il est recommandé d'utiliser Hibernate dans la couche de base de données car il peut être développé rapidement, sauf si c'est Internet. Parce qu'il implique une concurrence élevée, la couche de base de données utilise MyBatis, qui a une efficacité d'interaction des données plus rapide. Par conséquent, SSH ne peut pas être ignoré.
1. Qu'est-ce que SSH
SSH est un cadre intégré de Struts + Spring + Hibernate, et est actuellement un cadre open source populaire pour les applications Web.
Le système intégrant le cadre SSH est divisé en quatre couches en termes de responsabilités: couche de présentation, couche logique métier, couche de persistance de données et couche de module de domaine pour aider les développeurs à créer des applications Web avec une structure claire, une bonne réutilisation et une maintenance pratique à court terme. Parmi eux, Struts est utilisé comme l'infrastructure globale du système, responsable de la séparation de MVC, et dans la partie modèle du cadre Struts, en contrôlant les sauts commerciaux, en utilisant le cadre Hibernate pour fournir un soutien à la couche de persistance, les gère, les gère, les jambes de force et l'hibernate. L'approche spécifique est: utilisez des méthodes d'analyse orientées objet pour proposer certains modèles en fonction des besoins, implémentez ces modèles comme objets Java de base, puis écrivez l'interface DAO (objets d'accès aux données) et donnez l'implémentation DAO de Hibernate. La classe DAO implémentée par l'architecture Hibernate est utilisée pour réaliser la conversion et l'accès entre les classes Java et les bases de données. Enfin, le printemps gère et gère les fruts et l'hibernate.
---------- Baidu Encyclopedia
2. Les pièces impliquées dans SSH
3. Déploiement rapide de l'environnement
Ici, nous utilisons une petite démo pour sauver les clients pour démontrer l'intégration de SSH
1. Importez le package JAR requis
1). Struts2 Framework
* Struts-2.3.24 / Apps / Struts2-Blank / Web-Inf / Lib / *. Jar - Tous les packages JAR requis par Struts2
* Struts2-Spring-Plugin-2.3.24.jar --- Struts2 intègre le package du plug-in de Spring
2). Cadre hibernate
* Hibernate-Release-5.0.7.Final/lib/required/*.jar - Package Jar requis par Hibernate Framework
* slf4j-api-1.6.1.jar - Interface logarithmique
* SLF4J-LOG4J12-1.7.2.jar - Implémentation du journal
* MySQL-Connector-Java-5.1.7-Bin.jar - Package MySQL Driver
3). Cadre de printemps
* Package de base IOC
* Package de base AOP
* Modèles JDBC et packages de base de transaction
* Spring intègre le package de test JUnit
* Spring intègre le package Hibernate Core
* Spring intègre le package de noyau Struts2
2. Configurer le code lié à Spring and Struts dans web.xml
1) Configurer le filtre de noyau Struts2
Ceci est défini comme interceptant tous
<! - Configurer le filtre de noyau -> <filter> <filter-name> struts2 </filter-name> <filter-class> org.apache.struts2.dispatcher.ng.filter.strutspreeandexectefilter </ filter-Class> </filter> <filter> <filter-name> Struts2 </filter-name> <url-sattern> / * </ url-stern> </ filter-mapping>
2) Configurez l'écouteur Spring
Lorsque le service commencera, le fichier de configuration de ressort sera chargé en premier
<! - Configurez l'écouteur de Spring Framework Integrating Web -> <disener> <écouteur-classe> org.springframework.web.context.contextLoadoirListener </ auteur-class> </dinener>
3) Configurer le chemin de chargement par défaut
<! - L'auditeur charge le fichier Web-Inf par défaut. Vous devez configurer les paramètres pour charger le fichier spécifié -> <ftext-param> <param-name> contextConfigLocation </ param-name> <param-valeur> classpath: applicationContext.xml </ param-value> </ context-param>
Résumé: Tous les codes pour web.xml sont
<! - Configurez l'écouteur qui intègre le Web dans le framework Spring -> <disener> <écouteur-classe> org.springframework.web.context.contextloadherListener </ auteur-class> </ounerner> <! - L'auditeur charge le fichier web-inf par défaut, et nécessite des paramètres de configuration pour charger le fichier spécifié -> < <param-name> ContextConfiglocation </ Param-name> <Am param-Value> ClassPath: ApplicationContext.xml </ Param-Value> </ Context-Param> <! - Configurez les filtres de noyau -> <filter> <filter-name> Struts2 </filter-name> <filter-class> org.apache.struts2.dispatcher.ng.filter.strutSprepareAndexEcuteFilter </ filter-Class> </filter> <Lilter-Mapping> <filter-name> Struts2 </filter-name> <url-sattern> / * </rll-platern> </filter-mapping>
2. Écrivez des fichiers de configuration pertinents sous SRC
1) Spring: ApplicationContext.xml
Importer des contraintes liées
<? 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.springframeworkwork.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.xsdd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd "> </ beans>
2) Hibernate: hibernate.cfg.xml
Importez des contraintes pertinentes et configurez la base de données
<? xml version = "1.0" Encoding = "UTF-8"?> <! Doctype Hibernate-Configuration Public "- // Hibernate / Hibernate Configuration DTD 3.0 // en" "http://www.hibernate.org/dtd/hibernate> <Session-Factory> <! - doit configurer -> <propriété name = "hibernate.connection.driver_class"> com.mysql.jdbc.driver </ propriété> <propriété name = "hibernate.connection.url"> jdbc: mysql: //192.168.174.130: 3306 / ssh </ propriété> name = "hibernate.connection.username"> root </ propriété> <propriété name = "hibernate.connection.password"> root </ propriété> <propriété name = "hibernate.dialect"> org.hibernate.dialect.mysqldialect </ propriété> <! - Configuration optionnelle> <propriété = "Hibernate.Show_sql"> true> <propriété Name = "Hibernate.Show_sql"> true> <propriété Name = "Hibernate.Show_Sql"> True </ Property Name = "Hibernate.Show_Sql"> True </ Property Name = "Hibernate.Show_Sql"> TRUE <VERPTHERNED Name = "HiBERNate.Show_Sql"> TRUE <VERPTHERNED NAY = "HIBERNATE. name = "hibernate.format_sql"> true </ propriété> <propriété name = "hibernate.hbm2ddl.auto"> Update </ propriété> <! - Configurer le pool de connexion pour C3P0 -> <propriété Name = "Connection.Provider_Class"> Org.hibernate.Connection qui a du thelp0connectionprovider </ Property> -> <! - Fichier de configuration de mappage -> <mapping ressource = "com / clj / domain / client.hbm.xml" /> </ session-factory> </ hibernate-configuration>
3) Configurer log4j.properties
### Messages de journal direct vers STDOUT ### log4j.appender.stdout = org.apache.log4j.consoleAppenderLog4j.appendender.stdout.target = System.errlog4j.appender.stdout.layout = org.apache.log4j.patternlayoutlog4j.apprender.stdout.layout.ConversionPattern =% d {Absolute. % c {1}:% l -% m% n ### Messages directs pour déposer mylog.log ### log4j.appender.file = org.apache.log4j.fileAppenderlog4j.appendender.file.file = c /: mylog.loglog4j.appendender.file.layout = org.apache.log4j.patternlayoutlog4j.apprender.file.layout.ConversionPattern =% d {Absolute. % C {1}:% L -% m% n ### Set Log Niveaux - Pour plus de changement de journalisation verbeux 'Info' en 'Debug' ### log4j.rootlogger = info, stdout4) Struts2: struts.xml
Importer des contraintes liées
<? xml version = "1.0" Encoding = "UTF-8"?> <! Doctype Struts public "- // APache Software Foundation // Dtd Struts Configuration 2.1 // en" "http://struts.apache.org/dtds/struts-2.3.dtd"> <struts> </truts>
Résumé: Le fichier de configuration requis par SRC est illustré sur la figure
3. Configurez la couche DAO
Définir une interface et sa classe d'implémentation
Interface publique CustomerDAO {public void Save (client client);} classe publique CustomerDaOIMPl implémente CustomerDAO {public void Save (client client) {}}4. Définir l'interface de la couche commerciale et la classe d'implémentation
package com.clj.service; import com.clj.domain.customer; interface publique CustomerService {public void Save (client client);} Package com.clj.service; import org.springframework.transaction.annotation.transactional; import com.clj.dao.customerdao; import com.clj.domain.customer; / ** * Customery Layer * @Author Administrator * * / public class customerService ImplectiveService {// utilisé pour enregistrer les clients5. Définir la classe Pojo
HiberNate exploite des tables de base de données en fonctionnant des classes POJO pour atteindre la cartographie relationnelle des objets
package com.clj.domain; Client de classe publique {private long cust_id; chaîne privée cust_name; privé long cust_user_id; privé long cust_create_id; String privé Cust_Source; String privé Cust_Industry; chaîne privée cust_level; chaîne privée cust_linkman; String privé Cust_Phone; String privé Cust_Mobile; public long getCust_id () {return cust_id; } public void setCust_id (long 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 "client [cust_id =" + cust_id + ", cust_name =" + cust_name + ", cust_user_id =" + cust_user_id + ", cust_create_id =" + cust_create_id + ", cust_source =" + cust_source + ", cust_source =" + cust_source + ", CURS_SORCE =" + cust_industry + ", cust_level =" + cust_level + ", cust_linkman =" + cust_linkman + ", cust_phone =" + cust_phone + ", cust_mobile =" + cust_mobile + "]"; }}6. définir le client.hbm.xml
Ce fichier de configuration est lié à la classe POJO client. Ce fichier doit être placé sous le même package que la classe POJO client
<? xml version = "1.0" Encoding = "UTF-8"?> <! Doctype Hibernate-Mapping public "- // Hibernate / Hibernate Mapping Dtd 3.0 // en" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibirt-mappant> name = "com.clj.domain.customer" table = "cst_customer"> <id name = "cust_id" colonnen = "cust_id"> <générateur /> </ id> <propriété name = "cust_name" chronny = "cust_name" /> <propriété name = "cust_user_id" chronn = "cust_use_id" name = "cust_create_id" chronn = "cust_create_id" /> <propriété name = "cust_source" column = "cust_source" /> <propriété name = "cust_industry" column = "cust_level" chronn = "cust_linkman" /> <propriété name = "cust_linkman" /> <propriété name = "cust_phone" chronny = "cust_phone" /> <propriété name = "cust_mobile" chronn = "cust_mobile" /> </ class> </ hibernate-mapping>
Diagramme de construction du projet
4. Démonstration préliminaire de la démo pour la préservation des clients
Ici, nous définissons d'abord la couche de persistance à Heibernate, la couche commerciale à Struts2, et l'instance de création à ressortir
1. Définissez une interface pour enregistrer les clients et utiliser des formulaires de formulaire pour soumettre des données
Selon le nom de domaine, nous pouvons voir que la méthode générique de Struts2 est utilisée pour l'accès.
<Form id = form1 name = form1 action = "$ {pagecontext.request.contextPath} /customer_add.action" Method = Post> <! - TABLE Partie omise -> </ form>2. Configurer les demandes d'acceptation dans struts.xml, sautez à l'action spécifiée en fonction du nom et de la méthode de l'action et exécutez la méthode spécifiée
Spring intègre Struts2 Méthode One: l'action est gérée par Struts2 Framework
* Étant donné que le package Struts2-Sprig-Plugin-2.3.2.24.Jar est livré avec un fichier de configuration Struts-Plugin.xml, le code suivant est inclus dans le fichier de configuration
* <constante name = "structS.ObjectFactory" value = "printemps" /> Activez une constante. Si la constante est activée, la constante suivante peut être utilisée
* strut.objectfactory.spring.autowire = name, cette constante est une classe qui permet à l'action d'assembler automatiquement des objets Bean!
<? xml version = "1.0" Encoding = "UTF-8"?> <! Doctype Struts public "- // APache Software Foundation // Dtd Struts Configuration 2.1 // en" "http://struts.apache.org/dtds/struts-2.3.dtd"> <struts> <! - Configurer la structure du package -> <package = "crm" extends = "struts-default" namespace = "/"> <! - Configurer l'action client -> <! - Méthode 1: L'aciton est géré par Struts2 Framework -> <action name = "Customer_ *" Method = "{1}" /> </ package> </ struts>3. Configurez les haricots et transactions correspondants dans Spring ApplicationContext.xml
Ici, en utilisant la fonction IOC (Control Inversion) au printemps, la tâche de créer une instance est remise à la gestion du framework Spring
<bean id = "CustomerService"> <propriété name = "CustomerDao" Ref = "CustomerDao"> </ Property> </anEn> <bean id = "CustomerDao"> <propriété name = "HiberNatetemplate" Ref = "HiberNatetemplate" /> </ Bean> <Bean Id = "HiberNatetemplate"> <! </bEAN> </EANS>
4. Écrivez le code lié à la classe de mise en œuvre de la couche de persistance
Ici, la classe de modèle fournie par Hibernate est utilisée pour enfermer la session en interne, afin que la méthode de la session puisse être appelée.
/ ** * Couche de persistance * * @Author Administrator * * / public class CustomerDaOIMPL implémente CustomerDAO {// Enregistrer les données dans la base de données (Call Template Class (fourni par HiberNate, session encapsulée en interne)) Private HiberNateTtemplate HibernateTeTemplate; public void SetHiberNateTemplate (hibernatetemplate hibernatetemplate) {this.hibernateTemplate = hibernatetemplate; } / ** * Enregistrer le client * / public void Save (client client) {System.out.println ("Layer permanent: Save Client"); hibernateTemplate (). Save (client); }}5. Écrivez le code lié à la classe d'implémentation de la couche commerciale
Package com.clj.service; import org.springframework.transaction.annotation.transactional; import com.clj.dao.customerdao; import com.clj.domain.customer; / ** * Customery Layer * @Author Administrator * * / @ TransactionalPublic CustomerServiceService implémente le service client {privilège client) public void setCustomerDao (CustomerDAO CustomerDAO) {this.CustomerDao = CustomerDAO; } // Utilisé pour enregistrer le client public void Save (client client) {System.out.println ("Couche commerciale, enregistrer le client"); CustomerDAO.SAVE (client); }}6. Écrire du code lié à l'action
Voici la classe de modèle de Struts2
package com.clj.web.action; import org.apache.struts2.servletActionContext; import org.springframework.web.context.webappcationContext; import org.springframework.web.context.support.webapplicationContext com.opensymphony.xwork2.ActionSupport; Importer com.opensymphony.xwork2.modeLinven; / ** * Couche de contrôle du client * @Author Administrator * * / public class CustoSitAction étend ActionSupport implémente ModelDriven <piest> {// N'oubliez pas de nouveau client privé Customer = nouveau client (); client public getModel () {return client; } // Fournir des attributs de membres du service et fournir une méthode définie CustomerService Private CustomerService; public void setCustomerService (CustomerService CustomyingService) {this.CustomerService = CustomerService; } / ** * Enregistrer le client * @return * / public String add () {System.out.println ("web couche, enregistrer le client"); // Méthode 1: Créez la web usine (l'action est créée par Struts2) WebApplicationContext context = webApplicationContextUtils.getWebApplicationContext (servletActionContext.getServletContext ()); CustomerService CS = (CustomerService) context.getBean ("CustomyingService"); // APPEL MÉTHODE CS.SAVE (client); retourner aucun; }}5. Intégration de l'optimisation du projet
1. Intégration Spring Struts2 Méthode 2: L'action est gérée par Spring Framework
Mettez le fichier de configuration de classe d'action spécifique applicatonContext.xml dans le fichier de configuration, mais Remarque: struts.xml doit être modifié
<struts> <!-- Configure package structure--> <package name="crm" extends="struts-default" namespace="/"> <!-- Configure customer's Action --> <!-- Method 1: Aciton is managed by struts2 framework<action name="customer_*" method="{1}"/>---> <!-- Method 2: Action is managed by spring, and only the ID value of the srping configuration Le bean est requis sur la balise de classe -> <action name = "Customer_ *" Method = "{1}"> </ action> </ package> </ struts>2. Configurez la classe d'action dans ApplicationContext.xml
Remarque: 1) Le Framework Spring génère CustomerAction par défaut, tandis que le cadre Struts2 est multiple. Vous devez donc configurer scope = "Prototype"
2) Il n'y a pas d'assemblage automatique de Struts2 pour le moment. En action, vous devez configurer manuellement la propriété CustomerService et générer la classe de méthode de set en action.
<! - Configurer le module client -> <! - Impliquez: L'aciton configuré doit être multi-colonnes -> <bean id = "CustomerAction" scope = "Prototype"> <! - Remarque: Lorsque les struts gèrent des actions, basées sur un package de plugin de struts-Plugin, qui change de façon constante. Vous n'avez qu'à fournir une méthode définie. Cependant, l'action est gérée par le printemps et l'assemblage automatique n'est pas valide, vous devez donc effectuer manuellement l'injection de configuration -> <propriété name = "CustomerService" ref = "CustomerService"> </ Property> </anEd>
3. Configurer les transactions
Spring intègre Hibernate Method One: (Fichier de configuration avec hibernate.cfg.xml.
Dans le passé, lors de la lecture de Hibernate, Hibernate.cfg.xml a été géré par le cadre Hibernate. Son fichier de configuration peut générer SessionFactory. La couche de persistance charge ce fichier de configuration pour obtenir SessionFactory, créant ainsi une session générée en usine, en ajoutant, en supprimant et en modifiant les données. À l'heure actuelle, son fichier de configuration doit être remis à Spring Management, en utilisant pleinement les caractéristiques IOC de Spring.
Le framework Spring fournit une classe d'outils hibernatedaosupport, qui peut être héritée à l'avenir par DAO! ! Avant d'introduire le fichier de configuration Hibernate Core, la couche DAO doit hériter d'une classe parent HiberNatedAosupport, qui résume le modèle de transaction en interne.
Voir le code source:
1) Modifiez la classe d'implémentation de la couche de persistance correspondante et laissez hériter d'hibernatedaosupport
Package com.clj.dao; import org.springframework.orm.hibernate5.Hibernatetemplate; import org.springframework.orm.hibernate5.support.hibernatedaosupport; Import com.clj.domain.customer; / ** * LABERNETERNE * INHÉRIT * @Author Administrator * * / public classe CustomerDaOIMPL étend HiberNatedAosupport implémente CustomerDAO {// Enregistrez les données dans la base de données (appelez la classe de modèle (fournie par HiberNate, session encapsulée)) / * Private HiberNateTeTemplate HiberNateTemplate; public void SetHiberNateTemplate (hibernatetemplate hibernatetemplate) {this.hibernateTemplate = hibernatetemplate; } * / / ** * Enregistrer le client * / public void Save (client client) {System.out.println ("Couche permanente: Enregistrer le client"); this.GETHIBERNATETÉTÉ (). SAVE (client); }}2) Modifier la couche commerciale et activer les annotations de transaction
Package com.clj.service; import org.springframework.transaction.annotation.transactional; import com.clj.dao.customerdao; import com.clj.domain.customer; / ** * Customery Layer * @Author Administrator * * / @ TransactionalPublic CustomerServiceService implémente le service client {privilège client) public void setCustomerDao (CustomerDAO CustomerDAO) {this.CustomerDao = CustomerDAO; } // Utilisé pour enregistrer le client public void Save (client client) {System.out.println ("Couche commerciale, enregistrer le client"); CustomerDAO.SAVE (client); }}3) Modifier le fichier applicationcontext.xml
Présentez d'abord le fichier de configuration Hibernate
<! - Écrivez des beans, les noms sont fixés, fournis par Spring, utilisés pour charger le fichier de configuration de hibernate.cfg.xml -> <bean id = "sessionfactory"> <! - Path de configuration: lorsque le serveur est démarré, l'objet sera créé, chargeant ainsi le fichier Hibernate.cfg.xml, générant ainsi l'objet SessionFactory -> <propriété nom = "Configlocation" value = "classpath: hibernate.cfg.xml" /> </ bean>
Configurer la gestion des transactions de plate-forme: utilisé pour gérer les transactions. Notez que le cadre Hibernate est désormais utilisé, donc le gestionnaire de transactions du cadre Hibernate est nécessaire.
<! - Configurez d'abord le Gestion des transactions de plate-forme -> <bean id = "TransactionManager"> <! - Inject Transactions, la session peut gérer les transactions et l'usine peut créer une session -> <propriété name = "sessionfactory" ref = "sessionfactory" /> </EAND>
Annotation de transaction ouverte
<! - Annotation pour activer la transaction -> <tx: transaction-manager-manager = "transactionmanager" /> annotation
Supprimer la configuration de la classe de modèle et configurer SessionFactory pour la couche de persistance
<! - À l'avenir, Dao doit hériter de HiberNatedaOSupport et injecter sessionfactory -> <bean id = "CustomerDao"> <! - <Property Name = "La classe HiberNateTemplate" n'est pas injectée ici, mais ses session, car le template a besoin de session (enveloppée de session) - Ref = "SessionFactory" /> </EAN>
Tous les codes sont les suivants
<? 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.springframeworkwork.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.xsdd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd "> <! - Écrivez des beans, les noms sont fixés, et sont fournis par printemps pour charger le fichier de configuration"> <!! Chemin de configuration: Lorsque le serveur est démarré, l'objet sera créé, chargeant ainsi le fichier hibernate.cfg.xml, générant ainsi l'objet SessionFactory -> <propriété name = "ConfigLocation" Value = "ClassPath: HiberNate.cfg.xml" /> </ Bean> <! - Configurez les transactions de la session de la plate-forme, les transactions de la session de la plate-forme> <Bean Id = "TransactionManAgor"> <! Transactions, et l'usine peut créer une session -> <propriété name = "sessionfactory" ref = "sessionfactory" /> </ank> <! - Annotation pour activer les transactions -> <tx: les modules de clientèle axés sur l'annotation -> <! - L'acitonage configuré doit être multiples - <! SCOPE = "Prototype"> <! - Remarque: Lorsque Struts gère les actions, basées sur un package JAR avec Struts-Plugin, un nom constant Struts.ObjectFactory.spring.Autowire = Name est modifié pour l'activer et il peut être automatiquement assemblé. Vous n'avez qu'à fournir une méthode définie. Cependant, l'action est gérée par Spring, et l'assemblage automatique n'est pas valide, vous devez donc effectuer manuellement l'injection de configuration -> <propriété name = "customerService" ref = "CustomerService"> </ propriété> </-bee name = "hibernatetemplate" ref = "hibernatetemplate" /> -> <! - La classe de modèle n'est pas injectée ici, mais SessionFactory, car le modèle a besoin de session (session encapsulée) -> <propriété name = "SessionFactory" Ref = "SessionFactory" /> </ank> <! - La classe de Personnces (propriété Name = "Session" La couche hérite de HiberNatedAosupport, il n'est pas nécessaire de configurer -> <! - <bean id = "HiberNateTemplate"> Inject SessionFactory <Property Name = "SessionFactory" /> </bEAN> -> </bans>
4) Modifier la classe d'action
Étant donné que la classe d'implémentation de la couche commerciale est injectée, la méthode de la couche commerciale peut être appelée directement en ce moment sans charger le haricot
package com.clj.web.action; import org.apache.struts2.servletActionContext; import org.springframework.web.context.webappcationContext; import org.springframework.web.context.support.webapplicationContext com.opensymphony.xwork2.ActionSupport; Importer com.opensymphony.xwork2.modeLinven; / ** * Couche de contrôle du client * @Author Administrator * * / public class CustoSitAction étend ActionSupport implémente ModelDriven <piest> {// N'oubliez pas de nouveau client privé Customer = nouveau client (); client public getModel () {return client; } // Fournir des attributs de membres du service et fournir une méthode définie CustomerService Private CustomerService; public void setCustomerService (CustomerService CustomyingService) {this.CustomerService = CustomerService; } / ** * Enregistrer le client * @return * / public String add () {System.out.println ("web couche, enregistrer le client"); // Méthode 1: Créez l'usine Web (l'action est créée par Struts2) / * WebApplicationContext context = webApplicationContextUtils.getWebApplicationContext (servletActionContext.getServletContext ()); CustomerService CS = (CustomerService) context.getBean ("CustomyingService"); // APPEL MÉTHODE CS.SAVE (client); * / clientService.save (client); retourner aucun; }}Intégration Spring Hibernate Méthode deux: (fichier de configuration sans hibernate.cfg.xml)
Ici, nous allons supprimer le fichier de configuration central de Hibernate. Avant de supprimer, vous devez configurer le contenu pertinent dans son fichier de configuration dans le fichier ApplicationInConText.xml de Spring pour l'obtenir.
1. Vérifiez le contenu pertinent dans le fichier hibernate.cfg.xml
* Paramètres de base de la connexion à la base de données (4 paramètres principaux)
* Propriétés liées à l'hibernate
* Pool de connexion
* Map Fichiers
2. Introduire la configuration
Introduire le pool de connexion
<! - Configurez le pool de connexion pour C3P0 First-> <bean id = "DataSource"> <propriété name = "DriverClass" value = "com.mysql.jdbc.driver" /> <propriété name = "jdbcurl" value = "jdbc: mysql: //192.168.174.130: 3306 / ssh" /> <prewety " value = "root" /> <propriété name = "mot de passe" value = "root" /> </ank>
Modifiez le SessionFactory correspondant: car il n'y a pas de fichier de configuration pour hibernate.cfg.xml, vous devez modifier la configuration et injecter le pool de connexion.
Introduire un fichier de mappage d'objets: car le fichier de configuration de hibernate.cfg.xml n'est plus analysé et le fichier de configuration doit être injecté.
<! - Écrivez des haricots, les noms sont fixes et sont fournis par Spring pour charger le fichier de configuration de hibernate.cfg.xml -> <bean id = "sessionfactory"> <! - Chargez le pool de connexion d'abord-> <propriété name = "dataSource" Ref = "dataSource" /> <! key = "hibernate.dialect"> org.hibernate.dialect.mysqldialect </ prop> <prop key = "hibernate.show_sql"> true </prop> <prop key = "hibernate.format_sql"> true </ prop> <prop Key = "HiberNate.hbm2ddl.Auto"> à jour </ proPs> </ property> </ property> </ property> </ property> </ property> </ property> </ property> </ property> </ property <! - Introduire des fichiers de configuration de mappage -> <propriété name = "mappingResources"> <s list> <value> com / clj / domain / client.hbm.xml </value> </sist> </ propriété> </ank>
Maintenant: le code applicationContext.xml est le suivant
<? 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.springframeworkwork.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.xsdd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd "> <! Value = "com.mysql.jdbc.driver" /> <propriété name = "jdbcurl" value = "jdbc: mysql: //192.168.174.130: 3306 / ssh" /> <propriété name = "user" value = "root" /> <propriété name = "wsword" value = "root" /> </ bean> <! Pour charger le fichier de configuration de hibernate.cfg.xml -> <bean id = "sessionfactory"> <! - Chargez le pool de connexion first-> <propriété name = "dataSource" ref = "dataSource" /> <! - Load Dialect, chargement des options -> <propriété name = "HiberNateProperties"> <props> <prop. key = "hibernate.dialect"> org.hibernate.dialect.mysqldialect </ prop> <prop key = "hibernate.show_sql"> true </prop> <prop key = "hibernate.format_sql"> true </ prop> <prop Key = "HiberNate.hbm2ddl.Auto"> à jour </ proPs> </ property> </ property> </ property> </ property> </ property> </ property> </ property> </ property> </ property <! - Injecter le fichier de configuration de mappage -> <propriété name = "mappingResources"> <s list> <value> com / clj / domain / client.hbm.xml </value> </sist> </ / propriété> </Ean> <! - Configurer le gestionnaire de transactions de plate-forme en premier-> <bean id = "transactionmanager"> <! name = "sessionfactory" ref = "SessionFactory" /> </ank> <! - Annotation pour l'ouverture de transaction-manager = "TransactionManager" /> <! - Configurer le module client -> <! - Impliquer: L'aciton configuré doit être multi-colonne Struts-Plugin, A constant struts.objectfactory.spring.Autowire = le nom l'a allumé et peut être automatiquement assemblé. Vous n'avez qu'à fournir la méthode définie. 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）插入：
Couche persistante
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); }}Classe de test
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）以下为指定查询、查询所有、离线查询代码
Couche persistante
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(); }}Classe de test
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. 解决办法
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); }Classe de test
@Test public void run5(){ Customer customer=customerService.loadById(2L); System.out.println(customer); }Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.