Bon après-midi
Je me suis fixé comme objectif d'apprendre le framework Spring pour le langage Java. Au cours de l'étude, j'ai décidé de vérifier par moi-même l'algorithme d'apprentissage de Richard Feynman: organiser-simplifier-former un autre. En général, j'ai commencé à enregistrer une série de courtes leçons pour les débutants sur le travail au printemps. Pour ceux qui veulent répéter, j'ai présenté le
code source .
Leçon 01. Comprendre l'IoC
Rassemblons donc les poètes, laissons-les composer et nous lire leurs poèmes.
Tout d'abord, déclarez l'interface qui génère les versets
src \ main \ java \ spring \ interfaces \ Lyricist.java:package spring.intarfaces; public interface Lyricist { public String Generate(); }
Nous implémentons cette interface dans la
classe src \ main \ java \ spring \ impls \ Mayakovsky.java :
package spring.impls; import spring.intarfaces.Lyricist; public class Mayakovsky implements Lyricist { @Override public String Generate() { return " \r\n" + " \r\n" + " \r\n" + " ?"; } }
Nous écrirons que nous allons créer un objet Mayakovsky spécifique dans le fichier de configuration xml
src \ main \ resources \ 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:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="LyricistBean1" class="spring.impls.Mayakovsky"/> </beans>
Identifiant LyricistBean1 associé au nom de classe Mayakovsky. Presque tout est prêt, seule la classe appelante
src \ main \ java \ spring \ main \ Start.java est manquante :
package spring.main; import org.springframework.context.ApplicationContext; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import spring.intarfaces.Lyricist; public class Start { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml"); Lyricist lyr1 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr1.Generate()); ((ConfigurableApplicationContext) context).close();
Dans la classe Start, nous lisons notre fichier de configuration, avons créé une instance du poète nommé bean LyricistBean1. J'ai une copie du poète Mayakovsky. La fonction Generate () nous a renvoyé des chaînes immortelles:
Et toi
jeu nocturne
pourrait
sur une flûte de tuyau de drainage?
Leçon 02. Sélection d'une instance à créer via le fichier de configuration
Disons qu'un ami nous a aidé et a fourni une autre implémentation de notre
interface Lyricist
src \ main \ java \ spring \ impls \ Poushkin.java :
package spring.impls; import spring.intarfaces.Lyricist; public class Poushkin implements Lyricist { @Override public String Generate() { return " :\r\n" + " ,\r\n" + " ,\r\n" + " ."; } }
Dans le fichier de configuration ApplicationContext.xml, remplacez Mayakovsky par Poushkin.
Exécutez le programme. Nous
obtenons un résultat complètement différent
sans reconstruction :
Je me souviens d'un merveilleux moment
Tu es apparu devant moi
Comme une vision éphémère
Comme un génie de pure beauté.
Leçon 03. Beans dans le code, pas dans le fichier de configuration
Supposons que nous n'aimions pas donner le choix de la classe de poète que nous créons
entre les mains du destin dans le fichier de configuration.
Changer la classe Poushkin.java
- Ajouter une bibliothèque d'importation importe org.springframework.stereotype.Component;
- Placez l'annotation Component ("LyricistBean1") avant la déclaration de classe
Nous avons donc laissé entendre au printemps que nous voulons voir Poushkin sous la forme du premier poète, et pas de quelqu'un d'autre.
Il reste à corriger légèrement le fichier de configuration ApplicationContext.xml:
1. Ajoutez le contexte de l'espace de noms: xmlns: context = "
www.springframework.org/schema/context ";
2. Supprimez la ligne inutile: />
3. Ajoutez une commande à la place pour ajouter automatiquement des bacs de toutes les classes situées dans le répertoire spring.impls au programme:
<context: component-scan base-package = "spring.impls" />
Par conséquent, le fichier ApplicationContext.xml doit ressembler à ceci:
<?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" 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-4.3.xsd"> <context:component-scan base-package="spring.impls"/> </beans>
Nous commençons. Nous obtenons le même résultat que dans la leçon précédente.
Leçon 04. Classe de configuration
Débarrassons-nous complètement du fichier xml.
Tous les paramètres peuvent également être dans la classe java. Parfois, c'est pratique.
Ajoutez une classe de configuration spéciale
src \ main \ java \ spring \ main \ LyricistConfiguration.java à notre programme:
package spring.main; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; @ComponentScan(basePackages = { "spring.impls" }) @Configuration public class LyricistConfiguration { }
@ComponentScan montre dans quel répertoire chercher les beans.
@Configuration rapporte que notre classe est une configuration spéciale.
Voilà, le fichier xml n'est plus nécessaire. Reste à signaler cette nouvelle à notre classe principale:
- Complétez-le avec l'importation import org.springframework.context.annotation.AnnotationConfigApplicationContext nécessaire ;
- Remplacer la ligne de création de contexte
Contexte ApplicationContext = new AnnotationConfigApplicationContext (LyricistConfiguration.class);
Par conséquent, le
fichier principal
src \ main \ java \ spring \ main \ Start.java devrait ressembler à ceci:
package spring.main; import org.springframework.context.ApplicationContext; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import spring.intarfaces.Lyricist; public class Start { public static void main(String[] args) { ApplicationContext context = new AnnotationConfigApplicationContext(LyricistConfiguration.class); Lyricist lyr1 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr1.Generate()); ((ConfigurableApplicationContext) context).close();
Tout commence et produit toujours des lignes immortelles Pouchkine. Tout fonctionne. Mais déjà sans xml.
Leçon 05. Singleton et prototype
Explorez les capacités du fichier de configuration. Revenons donc au projet de la deuxième leçon. Essayons de créer deux instances de la classe Poushkin dans Start.java et assurons-nous que le grand poète est le même:
Lyricist lyr1 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr1.Generate()); System.out.println(lyr1.hashCode()); Lyricist lyr2 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr2.Generate()); System.out.println(lyr2.hashCode());
Et les versets sont les mêmes, et le code de hachage tombe. Tout va bien.
Ajoutez à notre projet un simple citoyen qui n'écrit pas les vers
src \ main \ java \ spring \ impls \ SimpleMan.java :
package spring.impls; import spring.intarfaces.Lyricist; public class SimpleMan implements Lyricist { @Override public String Generate() { return " , "; } }
Enregistrez la classe dans le fichier de configuration (immédiatement après le premier bac)
<bean id="LyricistBean2" class="spring.impls.SimpleMan"/>
Nous essayons de créer
Lyricist lyr1 = context.getBean("LyricistBean2", Lyricist.class); System.out.println(lyr1.Generate()); System.out.println(lyr1.hashCode()); Lyricist lyr2 = context.getBean("LyricistBean2", Lyricist.class); System.out.println(lyr2.Generate()); System.out.println(lyr2.hashCode());
Le citoyen est toujours le même. Le désordre ...
Modifiez l'enregistrement du bean dans le fichier de configuration en ajoutant le mot magique scope = "prototype"
Par conséquent, le fichier
src \ main \ resources \ ApplicationContext.xml ressemblera à ceci:
<?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:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="LyricistBean1" class="spring.impls.Poushkin" scope="singleton"/> <bean id="LyricistBean2" class="spring.impls.SimpleMan" scope="prototype"/> </beans>
Maintenant tout va bien. Les citoyens sont différents à chaque fois. Mais Pouchkine est toujours seul.
Les personnes attentives ont remarqué que le paramètre scope = "singleton" a été ajouté dans le premier bac, mais ce paramètre est utilisé par défaut, vous ne pouvez donc pas l'écrire.
C'est tout pour aujourd'hui. Si ce post passe par la modération, et j'ai le temps et l'énergie, il y aura une continuation sur AOP, JDBC, les transactions, MVC et autres sagesse.
Cordialement, Vladimir