1. Injection de dépendance (DI)
L'injection de dépendance semble très profonde, mais en fait, c'est: attribuer des valeurs aux attributs. Il existe deux méthodes au total. Le premier est sous la forme de paramètres du constructeur, et l'autre est sous la forme de la méthode de réglage.
1 injection de constructeur
1 Injecte en utilisant le constructeur
Méthode d'injection utilisant XML
A. Ordre des paramètres
<constructor-arg index = "0"> <value> zhang san </value> </ constructor-arg>
<constructor-arg index = "1"> <value> 56 </value> </ constructor-arg>
B. Type de paramètre
<constructor-arg type = "java.lang.integer"> <value> 56 </value> </ constructor-arg>
<constructor-arg type = "java.lang.string"> <value> zhang san </value> </ constructor-arg>
Exemples spécifiques
Si vous souhaitez injecter des paramètres dans une classe de personne maintenant, l'élève est une autre classe.
classe publique Personne {chaîne privée pid; nom de chaîne privé; étudiant étudiant privé; Public (String Pid, étudiant étudiant) {this.pid = pid; this.Student = étudiant; } Public Person (String pid, String Name) {this.pid = pid; this.name = name; }}Configurer ApplicationContext.xml. Si aucune configuration de paramètre n'est effectuée, une erreur sera signalée et le constructeur correspondant ne peut être trouvé. Si les paramètres correspondants sont configurés, le constructeur correspondant doit être déclaré dans la classe.
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" XSI: ScheMalation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-Beans-2.5.xsd"> <Bean Id = "Personne"> <! Un constructeur dans la classe de personne est la marque d'angle du paramètre. La valeur de type du paramètre. S'il s'agit d'une propriété de base, utilisez cette affectation ref pour référer au type attribution -> <constructor-arg index = "0" type = "java.lang.string" value = "aaa"> </ constructor-arg> <constructor-arg index = "1" ref = "student"> </ constructor-arg> </ean> <beep id = "person1"> <propriété name = "PID"> </pEPI </EAN> <Bean Id = "Student"> </bEAN> </EANS>
Écrivez la classe de test dixmlConstructorTest et effectuez un débogage de points d'arrêt. Vous constaterez que selon les paramètres de configuration, le constructeur entré est personne (String Pid, étudiant étudiant)
classe publique DixmlConstructOrest {@Test public void test1 () {applicationContext context = new ClassPathXmlApplicationContext ("ApplicationContext.xml"); Personne personne = (personne) context.getBean ("personne"); }}2 injection à l'aide de la méthode du secteur des propriétés
Méthode d'injection utilisant XML:
A. Injection de haricots simples Les haricots simples incluent deux types: Type d'emballage et chaîne
<bean id = "PersonService"> <! - Type de base, type de chaîne -> <propriété name = "Age" value = "20"> </ propriété> <propriété name = "name" value = "Zhang wuji"> </ propriété> </ bean>
B. cite d'autres haricots
<bean id = "personne" /> <bean id = "PersonService"> <propriété name = "personne" ref = "personne" /> </ank>
1.1 Collection de liste d'assemblage
<propriété name = "lists"> <s list> <value> list1 </value> <value> list2 </value> <ref bean = "personne" /> </sist> </ propriété>
1.2 Collection d'ensemble d'assemblage
<propriété name = "sets"> <set> <value> list1 </value> <value> list2 </value> <ref bean = "personne" /> </set> </ propriété>
1.3 Carte d'assemblage
<propriété name = "maps"> <map> <entrée key = "01"> <value> map01 </value> </ntry> <entrée key = "02"> <value> map02 </value> </ntry> </apm> </ propriété>
La valeur de <ntrying> dans la carte est la même que celle de <Sist> et <Set>, qui peut faire n'importe quel élément d'attribut valide. Il convient de noter que la valeur clé doit être une chaîne.
1.4 Propriétés d'assemblage
<propriété name = "props"> <props> <prop key = "01"> prop1 </prop> <prop key = "02"> prop2 </prop> </props> </ propriété>
Exemples spécifiques
1. Créez deux objets et étudiant
package xgp.spring.demo; import java.util.list; import java.util.map; import java.util.properties; import java.util.set; public de classe publique {chaîne privée pid; nom de chaîne privé; étudiant étudiant privé; listes de listes privées; ensembles de sets privés; Carte de carte privée; Propriétés privées Propriétés; objet privé [] objets; Public Person () {System.out.println ("Nouvelle personne"); } // omettre les méthodes Getter et Setter} package xgp.spring.demo; classe publique Student {public étudiant () {System.out.println ("New Student"); } public void sait () {System.out.println ("étudiant"); }}Configurer le fichier applicationContext.xml
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" XSI: ScheMalation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-Beans-2.5.xssd"> <! - Poup Personne et Student dans la propriété de conteneurs printemps utilisée pour décrire la valeur de la propriété de la personne. Si la propriété est un type de référence, utilisez Ref pour attribuer une valeur -> <bean id = "personne" init-méthod = "init" lazy-init = "true"> <propriété name = "pid" value = "1"> </ propriété> <propriété name = "name" value = "wang ermazi"> </ propriété> <propriété name = "Student" Ref = "Student"> </ Property> <propriété Nom = "Listes" <value> list2 </value> <refean = "student" /> </ propriété> <propriété name = "sets"> <set> <value> set1 </value> <value> set2 </value> <refean = "student" /> </ set> </ propriété> <propriété name = "map"> <map> <entrée clé = "Entrée"> <valeur> map1 </value> </prée> <entrée = ""> </ REFORM bean = "Student" /> </ entry> </ map> </ propriété> <propriété name = "Properties"> <props> <! - Aucun type de référence requis -> <pop key = "prop1"> prop1 </prop> <propriété key = "prop2"> prop2 </prop> </props> </ propriété> <propriété name = "objets"> <list> <value> aa </value> </ propriété> </bEAN> <Bean Id = "Student"> </bEAN> </EANS>
Écrivez une classe de test dixmlsetterTest
package xgp.spring.test; import org.junit.test; import org.springframework.context.applicationContext; import org.springframework.context.support.classpathxmlapplicationcontext; import xgp.spring.demo.Person; Classer public DixmlSetterTest {/ ** * qui fait le springer. Le conteneur de printemps fait-il? (1) Démarrez le conteneur à ressort * (2) Créez un objet pour les deux haricots de la personne et de l'élève * (3) Analyser l'attribut de nom de la propriété, épisser la méthode du secteur, analyser les attributs * valeur ou réf de la propriété, transmettre des paramètres à la méthode du secteur et utiliser la technologie de réflexion pour attribuer des valeurs à l'objet. * (4) Extraire l'objet du conteneur à ressort et appeler la méthode de l'objet. * 2. Quelle est l'ordre d'exécution des conteneurs de ressort? * / @Test public void test1 () {applicationContext context = new ClassPathXmlApplicationContext ("ApplicationContext.xml"); Personne personne = (personne) context.getBean ("personne"); System.out.println (Person.getPid ()); System.out.println (personne.getName ()); System.out.println (Person.getlists ()); System.out.println (Person.getSets ()); System.out.println (Person.getMap ()); System.out.println (Person.getObjects (). Length); }} / * 1 wang wu [list1, list2, xgp.spring.demo.student@76a9b9c] [set1, set2, xgp.spring.demo.student@76a9b9c] {entrée1 = map1, entrée2 = map2} 2 * / L'ordre d'exécution des conteneurs à ressort
1. Tous sont des paramètres par défaut
2. Set Student (paresseux-initi = true)
3. Set Person (paresseux-initi = true)
Résumer
Il existe deux méthodes pour injecter des paramètres. Le constructeur doit écrire le constructeur correspondant, le secteur doit générer la méthode du secteur correspondant et le constructeur par défaut est écrit.
2.5 La signification du CIO et du DI
Après avoir appris ces derniers, quelle est la signification de la découvrir? Écrivons un exemple de système de gestion de documents pour illustrer les exigences. Voir la figure ci-dessous
1. Écrivez l'interface du document
Document d'interface publique {public void read (); public void write ();}2. Écrire des classes d'implémentation WordDocument, ExcelDocument, PDFDocument
classe publique WordDocument implémente le document {public void read () {System.out.println ("Word Read"); } public void write () {System.out.println ("Word Write"); }}3. Écrivez un système de documentage DocumentManager
classe publique DocumentManager {document de document privé; public void setDocument (document de document) {this.Document = document; } public documentManager () {} public documentManager (document de document) {super (); this.Document = document; } public void read () {this.document.read (); } public void write () {this.document.write (); }}4. Écrivez un document de classe de test
/ ** * En utilisant IOC et DI, vous pouvez réaliser une programmation complète orientée vers l'interface * * / public class DocumentTest {/ ** * document document = new WordDocument (); * Cette ligne de code n'est pas entièrement programmée axée sur l'interface, car une classe spécifique apparaît sur le côté droit du signe égal * / @Test public void testDocument_nospring () {document document = new wordDocument (); DocumentManager DocumentManager = nouveau documentManager (document); DocumentManager.read (); documentManager.Write (); } / ** * Du côté du code, je ne sais pas qui implémente le document. Ceci est déterminé par le fichier de configuration de Spring * <bean id = "DocumentManager"> <! - Le document est une interface -> <propriété name = "document"> <! - WordDocument est une classe d'implémentation, attribuée à l'interface du document -> <ref bean = "pdfDocument" /> </ Property ClassPathxMlApplicationContext ("ApplicationContext.xml"); DocumentManager DocumentManager = (documentManager) context.getBean ("DocumentManager"); DocumentManager.read (); documentManager.Write (); }}À partir de ce qui précède, nous pouvons voir la différence entre ne pas appliquer le ressort et appliquer le printemps
<! - DocumentManager, WordDocument, ExcelDocument, PDFDocument est placé dans le conteneur de ressort -> <bean id = "WordDocument"> </Ean> <Bean Id = "ExcelDocument"> </Ean> <Bean ID = "PDFDocument"> </ECHED> <Bean Id = "PDFDocument"> </EAN> </EAND> <EAN ID = "DocumentManAr"> <! -> <propriété name = "Document"> <! - WordDocument est une classe d'implémentation, attribuée à l'interface de document -> <ref bean = "pdfDocument" /> </ propriété> </ bean>
L'utilisation de Spring ne nécessite que la configuration de l'objet <ref bean = ""> correspondant dans l'applicationContext, sans prêter attention à des classes d'implémentation spécifiques et implémenter une programmation complète axée sur l'interface. C'est pourquoi le printemps peut s'intégrer à tant d'outils.
2.6 MVC Instance Simulation Structs2
Description des exigences
Créer un répertoire de projet
codage:
1. Créez une couche Dao pour établir une interface Persondao et implémentez une classe PersondaOimpl
Interface publique Persondao {public void SavePerson ();} classe publique PersondaOIMPl implémente Persondao {@Override public void SavePerson () {System.out.println ("Save Person"); }}2. Établissez une couche de service, une interface de personnes et une classe de mise en œuvre de personnes PersonServiceImpl
Interface publique PersonService {public void SavePerson ();} public class PersonServiceIMPl implémente les personnes {private Persondao Persondao; public void setpersondao (persondao persondao) {this.persondao = persondao; } @Override public void SavePerson () {this.persondao.saveperson (); }}3. Créer une action, classe de personaction
Classe publique Personaction {Person-Service PersonService; public void setPerSonService (PersonService PersonService) {this.sonService = PersonService; } public void SavePerson () {this.personService.saveSerson (); }}4. Configurer l'applicationcontext.xml
<! - Mettez le service, Dao, classe d'action dans le conteneur de ressort -> <bean id = "Persondao"> </Eb> <bean id = "PersonService"> <propriété name = "Persondao"> <refEan = "Persondao" /> </ Property> </ Bean> <Bean Id = "Personaction"> <propriété Name = "PersonService"> <Ref Bean = "PersonSenvice" /> </ PersonService "> <Ref Bean =" Personsvice "
5. Écrivez la classe de test TestMvc
classe publique mvCTest {@Test public void testmvc () {applicationContext context = new ClassPathXmlApplicationContext ("ApplicationContext.xml"); Personaction personaction = (personaction) context.getBean ("personaction"); personaction.saveperson (); // sauver la personne}}L'exemple ci-dessus montre clairement la programmation orientée vers l'interface du printemps. La couche de service n'a besoin que d'appeler l'interface de la couche DAO, mais n'a pas besoin de prêter attention à la classe d'implémentation de la couche DAO, et l'action n'a qu'à appeler l'interface du service, mais n'a pas besoin de prêter attention à la classe d'implémentation du service.
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.