1 fonctionnalités de base de printemps
Spring est un cadre open source très actif; Il s'agit d'un cadre qui construit des systèmes Javaee multicouches basés sur le noyau, et son objectif principal est de simplifier le développement de l'entreprise.
Spring gère votre code de manière non invasive. Le printemps préconise "l'intrusion minimale", ce qui signifie que vous pouvez installer ou désinstaller le printemps au moment approprié, et le printemps rend Java brillant. (Principe ouvert et de fermeture), voici le principe de clôture.
2. Outils nécessaires pour développer le ressort
(Ici, nous sélectionnons d'abord Spring 2.5 puis 3.0)
2.1 Package de pot de Spring
Téléchargez le printemps à http://www.springsource.org/download, puis décompressez, trouvez le fichier de pot suivant dans le répertoire de décompression et copiez-le sur le chemin de classe
«La bibliothèque de classe de base de Spring est DIST / Spring.jar sous DIST dans le document de printemps
«La bibliothèque tierce introduite est tout le document de printemps sous Lib, Lib / Jakarta-Commons / Commons-Logging.jar
―Si la programmation d'aspect (AOP) est utilisée, les fichiers JAR suivants lib / aspectj / aspectjwweaver.jar et aspectjrt.jarlib / cglib / cglib-nodep-2.1_3.jar sont également requis
―Si vous utilisez les annotations dans JSR-250, telles que @ Resource / @ PostConstruct / @ Prestestroy, le fichier JAR suivant Lib / J2ee / Common-Annotations.jar est également nécessaire
Remarque: JSR (demande de spécification Java) fait référence à une demande formelle pour ajouter une spécification technique standardisée à JCP (processus communautaire Java). Tout le monde peut soumettre un JSR (demande de spécification Java) pour ajouter de nouvelles API et services à la plate-forme Java. JSR est devenu une norme importante dans le monde Java
2.2 Fichier de configuration de ressort
Par défaut, il s'agit du fichier applicationContext.xml. De nombreux fichiers XML peuvent être créés, et cela est généralement configuré dans les projets. (Créé dans le répertoire SRC)
3 Explication détaillée des fonctions de base du printemps
3.1 Springioc
Inversion de contrôle de Spring: remettez la création, l'initialisation, la destruction et d'autres tâches d'objets au conteneur de printemps. Contrôle le cycle de vie d'un objet par le conteneur à ressort.
étape:
•UN. Démarrer le conteneur à ressort
1. Trouvez des fichiers de configuration dans le chemin de classe pour instancier le conteneur
La copie de code est la suivante: ApplicationContext ctx = new ClassPathxmlApplicationContext (new String [] {"ApplicationContext.xml"});
Vous pouvez rechercher des fichiers XML dans l'ensemble du chemin de classe
* Chargez de cette façon. Vous devez mettre le fichier de configuration de ressort sous le chemin de classe de classe du projet actuel
* Le chemin de ClassPath fait référence au répertoire SRC du projet actuel, qui est l'emplacement de stockage du fichier source Java.
2. Trouvez des fichiers de configuration dans le chemin du système de fichiers pour instancier le conteneur
Le fichier de configuration de Spring peut spécifier plusieurs fichiers de configuration et peut être transmis par des tableaux de chaîne.
Remarque: utilisez souvent la première méthode pour démarrer le conteneur
• b. Extraire des objets du conteneur de ressort
Structure du conteneur à ressort:
3.2 Alias
<eans> <alias name = "personne" alias = "p" /// alias est un alias, vous pouvez obtenir la personne haricot via p. <Bean name = "Person" /> </ Beans>
Avec une telle configuration, l'effet de la dénomination en un seul endroit et de l'utilisation de différents noms à plusieurs endroits peuvent être obtenus.
3.3 Objets internes du conteneur à ressort
1 Comment créer un objet
1.1 Aucun constructeur de paramètres
<bean id = "helloworld"> </ank>
1.2 Méthode d'usine statique
<bean id = "helloworld2"
Factory-Method = "GetInstance"> </EAN>
1.3 Exemple de méthode d'usine
<bean id = "helloworldfactory"> </bant>
<bean id = "helloworld3" factory-bean = "helloworldfactory" factory-méthod = "getInstance"> </ank>
N'oubliez pas le concept. La première méthode est la plus utilisée, mais lors de l'intégration avec d'autres outils, le modèle d'usine d'instance est utilisé.
Exemple :
Configurer 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.xsd"> <! - Posez une classe dans un contenant de la classe de la classe de la classe est appelé un bean -> <! -> <bean id = "helloworld"> </ank> <! ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Factory-Method = "GetInstance" ></bean><!-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Créer une classe d'entité Helloworld
package com.itheima10.spring.createObject; public class helloworld {public void hello () {System.out.println ("bonjour"); }}Établir une usine statique HelloworldFactory
package com.itheima10.spring.createObject.Method; public class helloworldfactory {public static helloworld getInstance () {System.out.println ("méthode statique"); retourner new Helloworld (); }}Établir une usine physique helloworldfactory2
package com.itheima10.spring.createObject.Method; public class helloworldfactory2 {/ ** * L'objet d'usine doit être créé avant que la méthode puisse être appelée * @return * / public helloworld getInstance () {return new Helloworld (); }}Méthode de test d'écriture createObjectMethodTest
package com.itheima10.spring.createobject.method; import org.junit.test; import org.springframework.context.applicationContext; import org.springframework.context.support.classpathxmlapplicationcontext; / ** * Il s'agit de voir les deuxième et troisième méthodes de génération * @author zd * / / [* * Public Cass CreateObjectMethodTest {/ ** * Par défaut, le conteneur Spring appelle le constructeur par défaut d'une classe pour créer un objet * / @Test public void testCreateObject_Default () {ApplicationContext Context = new ClassPathXmlApplicationContext ("ApplicationContext.xml"); Helloworld helloworld = (helloworld) context.getBean ("helloworld"); helloworld.hello (); } / ** * Créez un objet à l'aide d'une usine statique * <bean id = "Helloworld2" Factory-Method = "GetInstance"> </EAN> Ce que le conteneur de printemps fait: la méthode GetInstance est appelée ClassPathxMlApplicationContext ("ApplicationContext.xml"); Helloworld helloworld = (helloworld) context.getBean ("helloworld2"); helloworld.hello (); } / ** * La méthode d'usine d'instance crée un objet * <bean id = "helloworldfactory" *> </ bean> * <bean id = "helloworld3" factory bean = "helloworldfactory" factory-method = "getInstance"> </ bean> ce qu'il faut faire à l'intérieur du conteneur de Spring: 1. Créer un Helloworldfactory objet * / @Test public void testCreateObject_InstanceFactory () {applicationContext context = new ClassPathXmlApplicationContext ("ApplicationContext.xml"); Helloworld helloworld = (helloworld) context.getBean ("helloworld3"); helloworld.hello (); }}2 Portée de l'objet
La portée d'un objet a deux propriétés: singleton et prototype. Singleton signifie singleton
2.1 Singleton (valeur par défaut)
Dans chaque conteneur IOC Spring, il n'y a qu'une seule instance d'objet (partagée).
2.2 Prototype
Permettre à l'instanciation des haricots plusieurs fois (créer une instance une fois utilisée). Le printemps ne peut pas être responsable de l'ensemble du cycle de vie d'un prototype de haricot. Cela signifie qu'il est de la responsabilité du client d'être clair sur le prototype d'objets de portée et de libérer les ressources coûteuses détenues par n'importe quel prototype de haricot.
<bean id = "helloworld" scope = "singleton"> </ank>
<bean id = "helloworld" scope = "Prototype"> </EAN>
Créer une classe Helloworld
classe publique helloworld {public list <string> lists = new ArrayList <string> (); public helloworld () {System.out.println ("Nouvelle instance"); } public void hello () {System.out.println ("Bonjour"); }}Créer une classe de test Scopetest
package com.itheima10.spring.scope; import org.junit.test; import org.springframework.context.applicationcontext; import org.springframework.context.support.classpathxmlapplicationcontext; public class scopetest {/ ** * placer un beeb et cette classe est un singleton, alors les propriétés de la classe deviendront partagées * / @Test public void testCreateObject_Scope_Default () {ApplicationContext context = new ClassPathXmlApplicationContext ("ApplicationContext.xml"); Helloworld hello1 = (helloworld) context.getBean ("helloworld"); hello1.lists.add ("aaaa"); hello2 = (helloworld) context.getBean ("helloworld"); hello2.lists.add ("bbbb"); System.out.println (helloworld.lists.size ()); // 2, et ne sort que la nouvelle instance} / ** * Si le fichier de configuration de Spring est le suivant: * <bean id = "helloworld" scope = "Prototype"> </ bean> alors le conteneur de printemps créera plusieurs objets pour * / @Test public void testCreateObject_Scope_Prototype () {applicationContext; Helloworld hello1 = (helloworld) context.getBean ("helloworld"); hello1.lists.add ("aaaa"); hello2 = (helloworld) context.getBean ("helloworld"); hello2.lists.add ("bbbb"); System.out.println (helloworld.lists.size ()); // 1, et uniquement une nouvelle instance}}3 Temps d'initialisation
Chargement paresseux - Par défaut, le bean sera initialisé au début du récipient, mais nous pouvons spécifier le paresseux-init = "true" du nœud de haricot pour retarder l'initialisation du haricot. Pour le moment, le haricot ne sera initialisé que si le haricot est récupéré pour la première fois. comme:
<bean id = "xxx" lazy-init = "true" />
Si vous souhaitez appliquer une initialisation retardée à tous les haricots, vous pouvez définir default-pazy-init = "true" dans les haricots racinaires, comme suit:
<beans default-pazy-init = "true" ...>
Spring instancie tous les haricots singleton à l'avance au démarrage par défaut. La première instanciation signifie que dans le cadre de l'initialisation, l'applicationContext crée et configure automatiquement tous les haricots singleton. C'est généralement une bonne chose. Parce que de cette manière, toutes les erreurs dans la configuration peuvent être découvertes immédiatement.
Lazy-Init est faux, Spring Container rapportera une erreur au début (une meilleure façon)
Lazy-initit est vrai et le conteneur à ressort fera une erreur lors de l'appel de la classe.
Configurer applicationContext.xml
<bean id = "helloworld" scope = "Prototype"> </bEAN> </EANS>
Créer une classe de test CreateObjectHentest
package com.itheima10.spring.createobject.when; import org.junit.test; import org.springframework.context.applicationContext; import org.springframework.context.support.classpathxmlapplicationcontext; Class public Createwowerwhente {/ ** * Order by Default * 1. Objet * 3. Méthode d'appel d'objet * * <bean id = "helloworld"> </ank> <bean id = "helloworld2"> </ank> parce que deux haricots sont déclarés dans le conteneur à ressort, le conteneur à ressort doit créer deux objets: si des fruits2, une erreur Hibernate, et les conteneurs à ressort sont intégrés, si l'erreur se produit dans le fichier de configuration de ressort, une erreur sera signalée lorsque le contenu TomCat est déclenché, en particulier le fichier de configuration de ressort, une erreur sera indiquée tôt. Si un haricot stocke une grande quantité de données, cette méthode n'est pas bonne et les données peuvent être bloquées en mémoire trop tôt. Si un bean n'est pas un singleton, peu importe comment il est configuré, l'objet doit être créé lorsqu'il s'agit d'un context.getBean * / @Test public void testCreateObject_When_Default () {ApplicationContext context = new ClassPathXmlApplicationContext ("ApplicationContext.xml"); context.getBean ("Helloworld"); } / ** * <bean id = "helloworld" lazy-init = "true"> </ bean> * commander * 1. Démarrez le conteneur de ressort * 2. Context.getBean * 3. Appelez la fonction du constructeur pour créer un objet * Description: Si les struts2, une erreur ne seront signalées que lorsque le bean est utilisé. Si un Bean stocke une grande quantité de données, il est nécessaire de charger des données en cas de besoin * / @Test public void testCreateObject_WHen_lazy () {ApplicationContext context = new ClassPathXmlApplicationContext ("applicationContext.xml"); context.getBean ("Helloworld"); }}4 INIT, Méthodes de détruire
Lorsque le printemps initialise les haricots ou détruit les haricots, un certain traitement est parfois nécessaire, donc le ressort peut appeler les deux méthodes de cycle de vie du haricot lors de la création et du démantèlement des haricots. Vous pouvez spécifier une méthode à utiliser.
<bean id = "foo" class = "... foo" init-méthod = "setup" Decoration-Method = "Teardown" />
Appelez la méthode init-méthode lorsque FOO est chargé dans le conteneur à ressort. Appeler le déploiement-méthode lorsque FOO est supprimé du conteneur (Scope = Singleton valide)
Écrire Helloworld
classe publique Helloworld {public Helloworld () {System.out.println ("Nouvelle instance"); } public void init () {System.out.println ("init"); } public void destrement () {System.out.println ("destruction"); } public void hello () {System.out.println ("Bonjour"); }}Écrivez la classe de test initdestroytest
package com.itheima10.spring.ioc.initdestroy; import org.junit.test; import org.springframework.context.applicationContext; import org.springframework.contex Le conteneur du conteneur * 2. Créer un objet Helloworld * 3. EXÉCUTER Méthode Init * Exécution automatique dans le conteneur de ressort * 4. Méthode d'appel d'objet * 5. La méthode de détruire ne peut être exécutée que lorsque le conteneur de ressort est fermé: le bean est un singleton * Cette méthode est également appelée en interne par le conteneur de ressort *: * Si un bean n'est pas un Singleton, le conteneur en interne n'est pas responsable de l'objet Dutruction. * Dans le conteneur de printemps, seulement si un bean est un singleton, le conteneur de ressort est responsable de la création, de l'initialisation et de la destruction des objets * Si un bean n'est pas un singleton, le conteneur de printemps n'est responsable que de la création et de l'initialisation * / @Test public Void TestinitDestroy () {applicationContext Context = new classpathxmlappationContext ("" ""xml"); Helloworld helloworld = (helloworld) context.getBean ("helloworld"); helloworld.hello (); ClassPathxMlApplicationContext ApplicationContext = (ClassPathxMlApplicationContext) Contexte; applicationContext.close (); }} Diagramme de séquence d'exécution:
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.