Cet article commence par un projet de centre commercial en ligne, en commençant par la construction de l'environnement et en intégrant S2SH étape par étape. Ce billet de blog résume principalement comment intégrer les struts2, hibernate4.3 et printemps4.2.
Pour intégrer les trois principaux cadres, vous devez d'abord commencer par construire divers environnements, c'est-à-dire, d'abord, vous devez construire les environnements de Spring, Hibernate et Struts2 pour vous assurer qu'ils n'ont aucun problème, puis les intégrer. L'ordre dans lequel ce billet de blog suit est: Construisez d'abord l'environnement de printemps -> puis construisez l'environnement Hibernate -> Intégrer le printemps et l'hibernate -> Construisez l'environnement Struts2 -> Intégrer Spring et Struts2.
1. Gestion de l'ensemble du pack de pot de projet
Le printemps a de nombreux packages en pot. Il est recommandé de les classer dans une catégorie, puis de les ajouter à la bibliothèque d'utilisateurs à son tour pour une gestion facile et claire en un coup d'œil. Ici, je résumerai les packages de pot de base requis pour l'ensemble du SSH et verrai l'image suivante:
Comme le montre la figure, tout d'abord, les pots de printemps sont divisés en quatre catégories: printemps-4.2.4-core, printemps-4.2.4-aop, printemps-4.2.4-persistence et printemps-4.2.4-web. Mettez tous les packages de base du printemps dans le noyau, mettez tous les liés à AOP dans AOP, mettez tout lié à la persistance (intégrée à Hibernate) dans la persistance et mettez tout lié au Web (intégré à Struts2) dans le Web. Quels forfaits JAR ont-ils chaque partie? Veuillez consulter la capture d'écran ci-dessous:
Remarque: Les packages de chaque catégorie ci-dessus ne contiennent pas tous les pots dans le package d'origine. Certains fichiers JAR ne sont pas utilisés. Ajoutez-les simplement lorsque le projet spécifique en a besoin. L'image ci-dessus est le package JAR le plus élémentaire requis pour garantir que l'environnement du projet peut créer le package JAR le plus basique.
2. Construisez un environnement de printemps
La capture d'écran ci-dessus du package JAR est tous les packages JAR qui ont été intégrés à la dernière fois. Lorsque vous construisez l'environnement pour la première fois, vous n'avez pas besoin de les ajouter tous en même temps. Vous pouvez les ajouter un peu par petit. Ceci est également plus propice à la compréhension de ce que les forfaits JAR de chaque partie ont. Bien sûr, il est également possible de les ajouter tous en même temps.
2.1 Ajouter un fichier de configuration bean.xml et packages de pot correspondants
Créez un nouveau projet, puis ajoutez votre propre bibliothèque à la bibliothèque d'utilisateurs. Voici deux principaux, à savoir Spring-4.2.4-Core et Spring4.2.4-AOP. Je n'entrerai pas dans les détails de l'ajout de packages en pot. Après avoir ajouté, ajoutez le fichier bean.xml dans le répertoire SRC. Il existe de nombreux modèles pour ce fichier en ligne, et il existe également des exemples fournis par Spring. Prenez simplement une copie, voyez l'image suivante:
2.2 Tester l'environnement IOC du Spring
Écrivons une classe Java normale java.util.date classe pour tester si Spring IOC est normal. S'il peut être injecté normalement dans le programme de test, cela signifie que l'environnement IOC de Spring est construit avec succès. Écrivons un cas de test ci-dessous:
/ ** * @Description Todo (en utilisant le débogage de l'annotation de Spring, ne prend en charge que Spring3.1 et supérieur) * @author ni Shengwu * * / * * Après Spring3.1, il y a un package de Spring-test-4.2.4.4.4. Ce package JAR est spécialement utilisé pour soutenir les tests basés sur l'annotation JUnit. Le package JAR est dans Spring-4.2.4-Core * Il y a un printempsjunit4classrunner.class dans ce package JAR, et vous pouvez l'ajouter avec l'objet @runwith annotation * * annotation @contextConfiguration signifie simplement injecter l'objet applicationContex @ContextConfiguration (locations = "classpath: beans.xml") public class sshTest {@Resource Private Date Date; @Test // Testez l'environnement de développement de Spring IOC public void SpringIoc () {System.out.println (date); }} Enfin, il peut sortir normalement: jeu 28 avril 22:45:13 CST 2016. Pour cette raison, l'environnement de printemps est construit.
3. Construisez un environnement d'hibernate
La construction de l'environnement d'Hibernate est plus compliquée que le printemps car elle utilise l'ingénierie inverse dans MyEclipse. Nous suivons les étapes suivantes pour construire l'environnement de développement Hibernate:
3.1 Ajouter le package JAR correspondant
Ici, nous ajoutons principalement deux packages JAR à la bibliothèque d'utilisateurs: Hibernate4.3.11 et le package MySQL Driver MySQL-Connector-Java-5.1.26, qui ne sera pas décrit en détail.
3.2 Créer une nouvelle base de données et un nouveau tableau
Déposez la base de données s'il existe un magasin; Créer un jeu de caractères par défaut de la boutique de base de données UTF8; utiliser la boutique; Tableau de dépôt si existe une catégorie; Créer une catégorie de table (/ * Numéro de catégorie, croissance automatique * / id int not null auto_increment, / * Nom de la catégorie * / type varchar (20), / * si la catégorie est une catégorie chaude, la catégorie chaude peut être affichée sur la page d'accueil * / hot bool par défaut, / * définir le numéro de catégorie sur la clé primaire * / la clé primaire (id));
3.3 DB Le navigateur se connecte à la base de données MySQL
Le navigateur DB fait référence à une fenêtre de vue dans MyEclipse. Vous pouvez voir intuitivement quelles bases de données et tables sont dans MySQL. La méthode pour ouvrir le navigateur DB: Window-> Ouvrir Perspective-> Browser DB Ouvre la fenêtre de travail du navigateur DB. S'il n'y a pas de navigateur DB, suivez les éléments suivants: Window-> Afficher la vue-> Autre-> Entrez le navigateur DB et trouvez-le pour l'ouvrir.
Après l'ouverture, nous commençons à nous connecter à la base de données MySQL. Cliquez avec le bouton droit -> Nouveau dans l'espace vide de la fenêtre du navigateur DB, et la boîte de dialogue suivante apparaîtra:
Après avoir rempli, cliquez sur Tester le pilote pour le tester. Le test passe le test et indique que le pilote de connexion de la base de données a été configuré, puis le terminer. De cette façon, nous pouvons voir la base de données MySQL 5.6 dans la fenêtre du navigateur DB. Cliquez avec le bouton droit pour l'ouvrir pour voir les bibliothèques et tables existantes dans la base de données, comme suit:
3.4 Créer un fichier de mappage XML et SessionFactory
SessionFactory est utilisé pour créer des sessions. Nous les créons de la manière suivante: cliquez avec le bouton droit sur le nom du projet -> MyEclipse-> Ajoutez des capacités d'hibernate. S'il n'y a pas d'ajout de capacités d'hibernate, cliquez sur FACETS DE PROJET-> Installez les facettes Hibernate et la fenêtre suivante apparaîtra:
Ensuite, ajoutez la prise en charge de Hibernate, c'est-à-dire Hibernate.cfg.xml Fichier de mappage et SessionFactory dans MyEclipse. Ici, nous créons principalement un package pour SessionFactory, et le package par défaut ne peut pas être utilisé.
Ensuite, ajoutez un pilote. Étant donné que nous avons déjà configuré un pilote, nous pouvons sélectionner directement le pilote nouvellement configuré ici.
Ensuite, puisque nous avons déjà ajouté notre propre réservation de bocal, il n'est pas nécessaire de choisir ici, il suffit de le terminer directement.
De cette façon, nous terminons la création du fichier de configuration Hibernate et de SessionFactory. Jetons un bref aperçu de ce qui se trouve dans la SessionFactory créé par MyEclipse:
classe publique HiberNaSesSessionFactory {private static final threadLocal <ession> threadLocal = new ThreadLocal <Session> (); // SessionFactory est utilisé dans SessionFactory Private Static org.hibernate.SessionFactory SessionFactory; // SessionFactory: Créez une usine pour Session Private Static Configuration Configuration = new Configuration (); ServiceRegistry statique privé ServiceRegistry; static {// initialiser sessionfactory try {configuration.configure (); ServiceRegistry = new ServiceRegistryBuilder (). ApplySettings (configuration.getProperties ()). BuildServiceRegistry (); SessionFactory = Configuration.BuildSessionFactory (ServiceRegistry); // Méthode pour créer SessionFactory dans HiberNate4} Catch (Exception E) {System.err.println ("%%%%% Création d'erreur Création de session% %%%%"); e.printStackTrace (); }} private HiberNaSesSessionFactory () {// La méthode du constructeur privé empêche la libération de nouveaux objets, garantissant que SessionFactory Singleton} public static Session getSession () lève HiberNateException {session session = (session) threadlocal.get (); // Obtenez la session du pool de threads if (session == null ||! Session.isopen ()) {// si le pool de thread est vide, ou l'ouverture de session échoue si (sessionfactory == null) {RebuildSessionFactory (); // Si le SessionFactory est vide, créez-le à nouveau, le même que la partie statique} session = (SessionFactory! = NULL)? SessionFactory.OpenSession (): null; // SessionFactory n'est pas vide, créez une session threadLocal.set (session); // Mettez ensuite cette session dans le pool de thread et obtenez-le la prochaine fois} Retour session; } public static void RebuildSessionFactory () {try {configuration.configure (); ServiceRegistry = new ServiceRegistryBuilder (). ApplySettings (configuration.getProperties ()). BuildServiceRegistry (); SessionFactory = Configuration.BuildSessionFactory (ServiceRegistry); } catch (exception e) {System.err.println ("%%%%% Création de sessionfactory %%%ec%"); e.printStackTrace (); }} public static void closesion () lève HiberNateException {session session = (session) threadLocal.get (); threadLocal.set (null); if (session! = null) {session.close (); }} public static org.hibernate.sessionfactory getSessionFactory () {// Fournir une interface publique pour permettre au monde extérieur d'obtenir cette session Singleton SessionFactory SessionFactory; } Public Static Configuration getConfiguration () {return Configuration; }} Il peut être vu à partir de la HiberNaSesSessionFactory créée que la technologie Singleton Pattern and Thread Pooring est principalement utilisée. Ce n'est pas difficile à comprendre.
3.5 Générer des fichiers de cartographie des modèles et ORM via l'ingénierie inverse
Ensuite, nous commencerons à utiliser l'ingénierie inverse pour créer un objet d'instance, c'est-à-dire le modèle correspondant à la table de base de données. Dans la fenêtre DB Browsera, cliquez avec le bouton droit sur la boutique de table que nous venons de créer et de sélectionner l'ingénierie inverse hibernate pour commencer à créer:
Il existe deux façons de le créer, basées sur des fichiers de configuration et basés sur les annotations. Cela dépend de l'humeur du développeur. Vous pouvez choisir:
Ensuite, à l'étape suivante, sélectionnez la méthode d'auto-inférences de la clé primaire native, puis complétez l'ingénierie inverse pour créer un mappage modèle et ORM.
Une fois terminé, le modèle de la catégorie sera généré et des mappages correspondants seront également générés dans le fichier hibernate.cfg.xml. Les mappages précédents basés sur les fichiers de configuration et les annotations basés sur les annotations seront différents.
3.6 Tester la base de données persistante hibernate
Parce qu'il n'a pas été intégré au printemps, c'est juste une construction simple de l'environnement de développement d'hibernate, nous n'avons donc pas besoin d'utiliser des annotations. Nous exécutons la saisie de données dans la base de données par un service directement nouveau.
Écrivez d'abord l'interface CatégoryService et la classe d'implémentation:
Catégorie d'interface publique Sercaire {public void Save (catégorie de catégorie); // Utiliser pour tester l'environnement Hibernate} classe publique CatégorieServiceImplt implémente catégorieService {@Override // Il n'y a pas d'intégration avec Spring public void Save (catégorie catégorie) {// Obtenir la session de session Session = HiberNaSessionFactory.getSession (); essayez {// manuel transaction session.getTransaction (). begin (); // Exécuter Business Logic Session.save (catégorie); // soumettre manuellement session.getTransaction (). Commit (); } catch (exception e) {session.getTransaction (). Rollback (); Jetez une nouvelle RuntimeException (E); } Enfin {hiberNaSessionFactory.closeSession (); }}} Ce qui suit est d'ajouter le test d'Hibernate dans le cas de test tout à l'heure:
@Runwith (springjunit4classrunner.class) @ContextConfiguration (locations = "classpath: beans.xml") public class sshTest {@Resource Private Date Date; @Test // Testez l'environnement de développement de Spring IOC public void SpringIoc () {System.out.println (date); } @Test // Tester / tester l'environnement de développement de Hibernate, car il n'y a pas d'intégration, vous pouvez directement de nouveau public void hihernate () {catégorieService categoryService = new categoryServiceImpll (); Catégorie catégorie = nouvelle catégorie ("Men's Casual", vrai); categoryService.save (catégorie); }}Nous avons vérifié la base de données et constaté qu'il y avait trop d'éléments qui venaient d'être insérés, ce qui signifie qu'il n'y avait aucun problème avec l'environnement hibernate. À ce stade, nous avons construit l'environnement de développement Hibernate.
4. Intégrer le printemps et l'hibernate
Après avoir construit l'environnement de développement pour le printemps et l'hibernate, nous avons commencé à intégrer les deux. Après avoir intégré Spring et Hibernate, vous pouvez utiliser AOP pour laisser le printemps gérer les transactions Hibernate. L'intégration de Spring et Hibernate commence principalement à partir de deux aspects: l'une consiste à importer les packages JAR nécessaires, et l'autre consiste à configurer le fichier bean.xml. Ci-dessous, nous intégrons le ressort et l'hibernate étape par étape.
4.1 Importer le package de pot correspondant
Il existe deux principaux packages JAR qui doivent être importés lors de l'intégration de Spring et Hibernate, Spring4.2.4-Persistence et C3P0-0.9.5.1. Pour les fichiers JAR spécifiques dans chaque package JAR, veuillez vous référer à la capture d'écran ci-dessus et ne sera pas décrit ici. Nous allons maintenant commencer à configurer le fichier bean.xml.
4.2 Configuration de la source de données de la source de données
Configurez d'abord la source de données, puis la partie correspondante dans hibernate.cfg.xml peut être tuée. Étant donné qu'il est configuré à Spring, Spring initialisera cette source de données, ce qui signifie que cela est laissé à ressort pour terminer, et la partie correspondante dans hibernate.cfg.xml peut être supprimée. comme suit:
<! - com.mchange.v2.c3p0.combopooledDatasource est dans le package com.mchange.v2.c3p0 de C3P0-0.9.5.1.jar package -> <bean id = "dataSource"> <propriété name = "DriverClass" value = "com.mysql.jdbc.driver" /> <propriété = "jdbcurl" value = "jdbc: mysql: // localhost: 3306 / shop" /> <propriété name = "user" value = "root" /> <propriété name = "mot de passe" value = "root" /> </ bean>
La partie qui doit être tuée dans hibernate.cfg.xml:
4.3 Configuration de SessionFactory
Le SessionFactory est configuré pour générer une session. De plus, HiberNatetemplate est également possible. Cependant, le SessionFactory est utilisé ici à la place de HiberNateTEmplate car HiberNateTemplate est fourni par Spring et dépend du printemps. Si le printemps n'est pas utilisé un jour, une erreur sera signalée. Et le SessionFactory est fourni par HiberNate, pas de problème. HiberNatetemplate est trop dépendante. Jetons un coup d'œil à la configuration spécifique:
<! - org.springframework.orm.Hibernate4.LocalSessionFactoryBean classe dans org.springframework.orm.Hibernate4 package de printemps-norm-4.2.4.release.jar package -> <bean id = "sessionfactory"> <propriété name = "dataSource" ref = "datasource" /> <propriété nom = "configlocation" value = "classpath: hibernate.cfg.xml" /> <! - Chargez le fichier de configuration Hibernate -> </ban>
Nous venons d'utiliser la source de données dans le SessionFactory pour référencer la source de données avec l'attribut Ref. Nous n'utilisons plus la configlocation ici. Nous chargeons directement le fichier hibernate.cfg.xml et utilisons la configuration dans le fichier de configuration Hibernate pour le rendre plus concis et pratique.
4.4 Configuration du gestionnaire de transactions
Le gestionnaire de transactions de configuration est utilisé pour gérer SessionFactory, afin que toutes les sessions générées par SessionFactory soient gérées de manière déclarative. La configuration est la suivante:
<! - org.springframework.orm.Hibernate4.HibernateTransactionManager Class Spring-Oorm-4.2.4.Release.jar package dans org.springframework.orm.Hibernate4 package -> <bean id = "TransactionManager"> <propriété name = "SessionFactory" Ref = "sessionfactory" /> </ean>
De même, nous pouvons utiliser le SessionFactory juste configuré et le référer avec l'attribut Ref. À ce stade, vous constaterez que tout le long du haut se trouve une série d'opérations, les citant un par un.
4.5 Configurer les conseils (notification)
Le but de configurer les conseils est de spécifier quelles méthodes nécessitent le type de mode de transaction. Voir la configuration:
<tx: conseils id = "conseils" transaction-manager = "transactionManager"> <tx: attributs> <tx: méthode name = "enregistrer *" propagation = "requis" /> <tx: attributs> </ tx: attributs> </ tx: conseils>
Requis signifie que s'il y a une transaction, la transaction actuelle est prise en charge. S'il n'y a pas, une nouvelle transaction est créée. Ce mode de transaction est appliqué à toutes les méthodes commençant par la sauvegarde, la mise à jour et la suppression, c'est-à-dire la prise en charge de la transaction est requise lors de l'ajout, de la suppression et de la modification de la base de données. Soutien signifie que s'il y a une transaction, la transaction actuelle est prise en charge, et s'il n'y a personne, ce sera bien.
4.6 Configuration des facettes AOP
<aop: config> <! - Configurez les classes de package pour entrer la transaction -> <aop: Pointcut id = "Pointcut" expression = "EXECUTION (* cn.it.shop.service.impl. *. * (..))" /> <aop: Advisor conseils-ref = "Conseils" Pointcut-ref = "Pointcut" /> <! Yahei; "> Et la coupe de points ci-dessus -> <! - AOP: Pointcut doit être écrit sur l'AOP: Advisor, sinon une erreur sera signalée -> </aop: config>
AOP est la programmation tangente. AOP: Pointcut définit une tangente. La configuration dans la propriété Expression signifie que toutes les méthodes dans le package cn.it.shop.service.impl, quelle que soit la valeur de retour et les paramètres, doivent entrer la transaction. Ce package appartient à la couche DAO et exploite directement la base de données. AOP: Les conseils combinent les notifications et les sections. Nous pouvons utiliser directement les conseils et la coupe de points configurés ci-dessus pour les présenter. Après cette configuration, cela signifie que toutes les méthodes dans le package cn.it.shop.service.impl doivent saisir la gestion des transactions. Plus précisément, les méthodes commençant par enregistrer, mettre à jour et supprimer utilisent la méthode requise, et d'autres méthodes utilisent la méthode de support. Cela facilite la compréhension de la signification de cette configuration.
4.7 Résultats de l'intégration de test
Lorsque nous avons déjà construit l'environnement Hibernate, nous avons testé que nous avons directement nouveau un service pour faire fonctionner la base de données, car il n'avait pas été intégré au printemps à ce moment-là. Maintenant, après la configuration de beans.xml, Spring est autorisé à gérer les transactions Hibernate. Par conséquent, le test actuel doit remettre le service à la gestion du printemps, l'injecter via le printemps et s'appuyer sur SessionFactory. Si les données peuvent être insérées dans la base de données, cela signifie que la transaction est OK.
Tout d'abord, nous devons faire correspondre ce service dans le fichier de configuration de Spring Bean.xml:
Copiez le code comme suit: <bean id = "categoryService">
<propriété name = "sessionfactory" ref = "sessionfactory" /> <! - La dépendance SessionFactory utilise le SessionFactory que nous avions précédemment équipé ->
</ban>
Deuxièmement, nous devons ajouter une méthode à l'interface CatégoryService et à sa classe de mise en œuvre catégorieServiceIMPL pour tester la situation d'intégration:
Catégorie d'interface publique Sercaire {public void Save (catégorie de catégorie); // Utilisé pour tester la mise à jour de la vide publique de l'environnement Hibernate (catégorie de catégorie); // Utilisé pour tester l'intégration de Spring et Hibernate} classe publique CatégorieServiceImpl implémente catégorieService {@Override // La situation où il n'y a pas d'intégration avec le printemps public void Save (catégorie catégorie) {// Obtenir la session de session = HiberNaSesSesSedFactory.getSession (); essayez {// manuel transaction session.getTransaction (). begin (); // Exécuter Business Logic Session.save (catégorie); // soumettre manuellement session.getTransaction (). Commit (); } catch (exception e) {session.getTransaction (). Rollback (); Jetez une nouvelle RuntimeException (E); } Enfin {hiberNaSessionFactory.closeSession (); }} / * Spring et Hibernate l'ensemble * / Session Private Session SessionFactory; // Définir une sessionFactory // Lorsque vous devez utiliser SessionFactory, Spring injectera sessionFactory dans public void setSessionFactory (sessionFactory SessionFactory) {this.sessionfactory = sessionFactory; } Session protégée getSession () {// Obtenez la session à partir du thread actuel. Sinon, créez une nouvelle session de retour sessionfactory.getCurrentession (); } @Override // La situation après Spring et Hibernate est intégrée Public Void Update (catégorie Catégorie) {getSession (). Update (catégorie); }} Maintenant, nous pouvons ajouter des méthodes de test à la classe de test pour tester les résultats après l'intégration du ressort et de l'hibernate:
@Runwith (springjunit4classrunner.class) @ContextConfiguration (locations = "classpath: beans.xml") public class sshTest {@Resource Private Date Date; @Resource Private CatégoryService CatégoryService; @Test // Test Spring IOC Development Environment public void SpringIoc () {System.out.println (Date); } @Test // Test // Test de l'environnement de développement de HiberNate, car il n'y a pas d'intégration, vous pouvez directement nouveau public void hihernate () {catégorieService categoryService = new categoryServiceImpll (); Catégorie catégorie = nouvelle catégorie ("Men's Casual", vrai); categoryService.save (catégorie); } @Test // Tester public void hibernateAndSpring () {categoryService.update (nouvelle catégorie (1, "Casual Women's", True)); // Catégorie Service injecté d'en haut au printemps}}Ensuite, nous avons vérifié la base de données et constaté que la catégorie avec id = 1 a été modifiée dans un style de femme occasionnel, ce qui signifie que la mise à jour a réussi. À ce stade, le printemps et l'hibernate ont été intégrés avec succès.
5. Construisez un environnement Struts2
5.1 Ajouter des packages de configuration et de bocal correspondants
J'ai mis le package JAR requis pour que Struts2 s'exécute dans la bibliothèque de Struts2.3.41, donc je peux simplement le présenter directement, et je ne le répéterai pas. De plus, le fichier web.xml doit être configuré comme suit:
<? xml version = "1.0" Encoding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://java.sun.com/xml/ns/javaee" XSI: ScheMalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id = "webapp_id =" 3.0 " <splay-name> e_shop </ display-name> <leen welcome-file-list> <leen welcome-file> index.jsp </venke-file> </ welcome-file-list> <filter> <filter-name> struts2 </filter-name> <filter-class> org.apache.struts2.dispatcher. </filter> <mappage filtrant> <filtre-name> struts2 </filter-name> <url-stern> *. Action </url-sattern> </filter-mapping> </low -pp>
Comme ci-dessus, nous avons configuré un filtre StruTsprepareAndexecuteFilter et réglé le schéma d'URL du filtre à * .Action, c'est-à-dire que les suffixes .Action passeront d'abord par ce filtre, qui est également l'entrée de Struts2.
5.2 Créez l'action et configurez-la dans le fichier strut.xml
Nous créons une action comme suit:
Catégorielle de classe publique étend ActionSupport {Private CatégoryService categoryService; // CatégoryService est défini pour voir intuitivement les différences avant et après l'intégration avec Spring public void setCategoryService (catégorieService categoryService) {this.categoryService = catégoryService; } public String Update () {System.out.println ("---- Update ----"); System.out.println (catégorieService); // Sortie différente de retour "index"; } public String Save () {System.out.println ("---- Save ----"); System.out.println (catégorieService); // Ouvrir différents rendements "index" avant et après l'intégration; }} Ensuite, nous configurons le fichier strut.xml, qui est placé dans le répertoire SRC:
<? xml version = "1.0" Encoding = "UTF-8"?> <! Doctype Struts public "- // APache Software Foundation // Dtd Struts Configuration 2.3 // en" "http://struts.apache.org/dtds/struts-2.3.dtd"> <stretts> <package name = "shop" extend = "struts"> <- - - package nom = "shop catégorie_update.actioCan: méthode d'accès à mise à jour -> <action name = "catégorie_ *" méthode = "{1}"> <result name = "index"> / index.jsp </sult> </ action> </ package> </ struts> 5.3 Tester l'environnement Struts2
La méthode de test est: Écrivez une action d'accès JSP, et si l'action peut être créée, cela signifie que l'environnement Struts2 est OK. Autrement dit, une série de processus dans Struts2 peut être terminée normalement: jsp -> strut.xml -> action -> strut.xml -> jsp, de sorte que l'environnement de Struts2 est prêt. Écrivons un index simple.jsp
<% @ Page Language = "Java" Import = "Java.util. *" Pageencoding = "UTF-8"%> <! DocType Html Public "- // W3C // DTD HTML 4.01 Transitional // En"> <html> <A-Head> <Titre> My JSP 'Index.jsp' Page de départ </ Title> accessible -> </ span> <a href = "$ {pagecontext.request.contextpath} /category_update.action"> Access update </a> <a href = "catégorie_save.action"> Access Save </a> </ body> </ html> Ensuite, nous déployons le projet suivant, ouvrez le serveur Tomcat, entrez: http: // localhost: 8080 / e_shop / index.jsp Dans le navigateur, la page JSP normale apparaîtra, puis cliquez sur deux boutons, tout en passant à index.jsp, puis nous jetons un coup d'œil aux informations de sortie de la console:
---mise à jour---
nul
---sauvegarder---
nul
Cela montre qu'une ligne de Struts2 a été terminée et il n'y a aucun problème avec l'environnement. À ce stade, l'environnement de développement Struts2 a été construit.
Nous voyons que la console sort nul, ce qui signifie que le service de catégorie est vide, ce qui signifie que nous n'avons pas du tout le service de catégorie, car nous n'avons pas intégré au ressort et que nous n'avons pas été injectés, donc Null est normal. Nous tournons le long de la sortie d'informations de la console et nous trouverons un message: Choisir Bean (Struts) pour (com.opensymphony.xwork2.ObjectFactory). Les supports disent que les jambes de force sont générées par Struts2 avant d'être intégrées au printemps.
6. Intégration Spring and Struts2
6.1 Ajouter le package JAR correspondant
Lorsque Spring et Struts2 sont intégrés, le package JAR est principalement dans le printemps4.2.4-Web, y compris Struts2-Spring-Plugin-2.3.24.1.jar. Le package de guidage ne sera plus décrit.
6.2 Laisser l'action et ses dépendances à la gestion du printemps
Configurer l'action et ses dépendances dans le fichier de configuration de Spring Bean.xml. Nous n'avons actuellement qu'une seule action, qui est configurée comme suit:
<bean id = "date" /> <bean id = "catégorieAction" scope = "prototype"> <propriété name = "catégorieService" ref = "categoryService" /> <! - La catégorie dépendante est configurée lors de l'intégration de ce qui précède et de l'hibernate -> </ bean>
6.3 Modifier la configuration dans struts.xml
Il s'avère que dans strut.xml, l'attribut de classe correspond au nom entièrement qualifié de l'action spécifique. Modifiez maintenant la valeur de l'attribut de classe à la valeur d'ID de l'action configurée au printemps, c'est-à-dire CatégoryAction, comme suit:
<trutts> <package name = "shop" étend = "struts-default"> <! - La classe correspond à la valeur d'ID de l'action configurée dans le printemps, car elle doit être remise à Spring Management -> <Action name = "catégorie_ *" Method = "{1}"> <Result name = "index"> / index.jsp </sult> </ action> </macking> </mack 6.4 Configurer l'auditeur
Configurez l'écouteur ContextLoaderListener dans web.xml afin que les fichiers de configuration de ressort puissent être chargés lorsque le serveur démarre. comme suit:
<? xml version = "1.0" Encoding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://java.sun.com/xml/ns/javaee" XSI: ScheMalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id = "webapp_id =" 3.0 " <splay-name> e_shop </ display-name> <leen welcome-file-list> <leen welcome-file> index.jsp </venke-file> </ welcome-file-list> <filter> <filter-name> struts2 </filter-name> <filter-class> org.apache.struts2.dispatcher. </filter> <mapping-mapping> <filter-name> struts2 </filter-name> <url-potern> *. Action </url-sattern> </filter-mapping> <! - La priorité de démarrage de l'auditeur dans web.xml est plus élevée que celle des filtres, donc cela n'a pas d'importance si elle est judiciaire ci-dessous -> <ouciner> <ouciner-Class> org.springframework.web.context.contextLoaderListener </ écouteur-CLASS> </ auteur> <IFFTEFT-PARAM> <AMAM-NAME> contextConfiglocation </ Param-Name> </AtHI-VALUE> CLASSPATH: Beans.xml </ param-valent> </ptext-praram> </ Web-Apple>
6.5 Résultats de l'intégration de test
Nous ajoutons une nouvelle instruction à l'action pour mettre à jour la base de données, comme suit:
La catégorie des classes publiques étend ActionSupport {Catégorie de catégorie privée; // Définir une variable de membre privé pour recevoir des paramètres apportés par l'URL. Notez que les méthodes GET et SET doivent être écrites ci-dessous. Catégorie de catégorie privée catégorie de service; public void setCategoryService (catégorieService categoryService) {this.categoryService = categoryService; } public String Update () {System.out.println ("--- Update ---"); System.out.println (catégorieService); // Parce qu'il a été intégré à Spring, vous pouvez obtenir ce CatégoryService. Il n'est pas nul après l'impression de catégorieService.update (catégorie); // Ajouter une nouvelle instruction pour mettre à jour le retour "index" de la base de données; } public String Save () {System.out.println (catégorieService); return "index"; } Public Catégorie GetCategory () {Retour Catégorie; } public void setCategory (catégorie catégorie) {this.category = catégorie; }} Ensuite, nous modifions le fichier index.jsp, comme suit:
<% @ Page Language = "Java" Import = "Java.util. *" Pageencoding = "UTF-8"%> <! Doctype Html public "- // w3c // dtd html 4.01 transitional // en"> <html> <adread> <Titre> My JSP 'index.jsp' Page de départ </ Title> href = "$ {pageContext.request.contextPath} /category_update.action?category.id=2&category.type=gga&category.hot=false"> Access Update </a> <a href = "catégorie_save.action"> Access Save </a> </odody> </html> Ensuite, nous déployons le projet suivant, ouvrirons le serveur Tomcat, entrez: http: // localhost: 8080 / e_shop / index.jsp Dans le navigateur, la page JSP normale apparaîtra, puis cliquez sur le bouton "Accès à la mise à jour", tout en passant à index.jsp, puis nous examinons les informations de sortie de la console:
--- Mise à jour --- cn.it.shop.service.impl.categoryserviceimpl@7c5ecf80 hibernate: catégorie de mise à jour set hot = ?, type =? où id =?
Nous pouvons sortir les informations de l'objet CatégoryService et pouvons également sortir l'instruction SQL lors de l'exécution de l'instruction de mise à jour. Ensuite, nous interrogeons la base de données et constatons que le type de données avec id = 2 a été mis à jour vers GGA et HOT a été mis à jour en false. Nous retournons la sortie d'informations de la console vers le haut et nous trouverons un message: Choisir Bean (printemps) pour (com.opensymphony.xwork2.ObjectFactory), avec le ressort des supports. Par rapport à la situation ci-dessus, nous pouvons voir qu'après que Struts2 est intégré au printemps, l'action est remise au printemps pour la gestion.
À ce stade, l'intégration de Struts2, HiberNate4 et Spring4 a été achevée, et nous pouvons le développer dans l'environnement SSH ensuite!
Le package JAR complet requis pour l'intégration SSH introduite dans cet article: Téléchargement gratuit
L'adresse de téléchargement du code source de l'intégralité du projet: //www.vevb.com/article/86099.htm
Adresse originale: http://blog.csdn.net/eson_15/article/details/51277324
(Remarque: À la fin, le téléchargement du code source de l'ensemble du projet est fourni! Tout le monde est invité à collectionner ou à suivre)
Ce qui précède est l'intégralité du contenu de cet article. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.