Introduction au Spring ClassPathXmlApplicationContext

1. Vue d'ensemble

Le cœur de Spring Framework est, en termes simples, un conteneur IoC utilisé pour gérer les beans.

Il existe deux types de conteneurs de base dans Spring: la Bean Factory et le contexte d'application. Le premier fournit des fonctionnalités de base, qui sont présentées ici; ce dernier est un sur-ensemble du premier et est le plus largement utilisé.

ApplicationContext est une interface dans le package org.springframework.context et il a plusieurs implémentations, et le ClassPathXmlApplicationContext en fait partie.

Dans cet article, nous allons nous concentrer sur les fonctionnalités utiles fournies par ClassPathXmlApplicationContext .

2. Utilisation de base

2.1. Initialiser le conteneur et gérer les beans

ClassPathXmlApplicationContext peut charger une configuration XML à partir d'un chemin de classe et gérer ses beans:

Nous avons une classe étudiante :

public class Student { private int no; private String name; // standard constructors, getters and setters }

Nous configurons un bean Student dans classpathxmlapplicationcontext-example.xml et l'ajoutons dans un classpath:

Nous pouvons maintenant utiliser le ClassPathXmlApplicationContext pour charger la configuration XML et obtenir le bean Student :

@Test public void testBasicUsage() { ApplicationContext context = new ClassPathXmlApplicationContext( "classpathxmlapplicationcontext-example.xml"); Student student = (Student) context.getBean("student"); assertThat(student.getNo(), equalTo(15)); assertThat(student.getName(), equalTo("Tom")); Student sameStudent = context.getBean("student", Student.class); assertThat(sameStudent.getNo(), equalTo(15)); assertThat(sameStudent.getName(), equalTo("Tom")); }

2.2. Configurations XML multiples

Parfois, nous voulons utiliser plusieurs configurations XML pour initialiser un conteneur Spring. Dans ce cas, nous devons simplement ajouter plusieurs emplacements de configuration lors de la construction du ApplicationContext :

ApplicationContext context = new ClassPathXmlApplicationContext("ctx.xml", "ctx2.xml");

3. Capacités supplémentaires

3.1. Arrêtez le conteneur Spring IoC avec élégance

Lorsque nous utilisons le conteneur Spring IoC dans une application Web, les implémentations ApplicationContext basées sur le Web de Spring arrêteront le conteneur correctement lorsque l'application est arrêtée, mais si nous l'utilisons dans un environnement non Web, tel qu'une application de bureau autonome, nous doivent enregistrer un hook d'arrêt auprès de la JVM par nous-mêmes pour vous assurer que le conteneur Spring IoC est arrêté correctement et appelle les méthodes destroy pour libérer les ressources.

Ajoutons une méthode destroy () à la classe Student :

public void destroy() { System.out.println("Student(no: " + no + ") is destroyed"); }

Nous pouvons maintenant configurer cette méthode comme la méthode destroy du bean étudiant :

Nous allons maintenant enregistrer un hook d'arrêt:

@Test public void testRegisterShutdownHook() { ConfigurableApplicationContext context = new ClassPathXmlApplicationContext( "classpathxmlapplicationcontext-example.xml"); context.registerShutdownHook(); }

Lorsque nous exécutons la méthode de test, nous pouvons voir que la méthode destroy () est appelée.

3.2. Internationalisation avec MessageSource

L' interface ApplicationContext étend l' interface MessageSource et fournit donc une fonctionnalité d'internationalisation.

Un conteneur ApplicationContext recherche automatiquement un bean MessageSource lors de son initialisation et le bean doit être nommé comme messageSource .

Voici un exemple d'utilisation de différentes langues avec MessageSource :

Tout d'abord, ajoutons un répertoire de dialogue dans un chemin de classe et ajoutons deux fichiers dans le répertoire de dialogue: dialog_en.properties et dialog_zh_CN.properties .

dialog_en.properties :

hello=hello you=you thanks=thank {0}

dialog_zh_CN.properties :

hello=\u4f60\u597d you=\u4f60 thanks=\u8c22\u8c22{0}

Configurez le bean messageSource dans classpathxmlapplicationcontext-internationalization.xml :

    dialog/dialog    

Ensuite, obtenons les mots de dialogue de différentes langues avec MessageSource :

@Test public void testInternationalization() { MessageSource resources = new ClassPathXmlApplicationContext( "classpathxmlapplicationcontext-internationalization.xml"); String enHello = resources.getMessage( "hello", null, "Default", Locale.ENGLISH); String enYou = resources.getMessage( "you", null, Locale.ENGLISH); String enThanks = resources.getMessage( "thanks", new Object[] { enYou }, Locale.ENGLISH); assertThat(enHello, equalTo("hello")); assertThat(enThanks, equalTo("thank you")); String chHello = resources.getMessage( "hello", null, "Default", Locale.SIMPLIFIED_CHINESE); String chYou = resources.getMessage( "you", null, Locale.SIMPLIFIED_CHINESE); String chThanks = resources.getMessage( "thanks", new Object[] { chYou }, Locale.SIMPLIFIED_CHINESE); assertThat(chHello, equalTo("你好")); assertThat(chThanks, equalTo("谢谢你")); }

4. Une référence à ApplicationContext

Parfois, nous devons obtenir la référence d' ApplicationContext à l'intérieur des beans gérés par celui-ci, nous pouvons utiliser ApplicationContextAware ou @Autowired pour ce faire. Voyons comment utiliser ApplicationContextAware fonctionne:

Nous avons une classe de cours avec un nom:

public class Course { private String name; // standard constructors, getters and setters }

Nous avons une classe Teacher qui assemble ses cours en fonction des beans du conteneur:

public class Teacher implements ApplicationContextAware { private ApplicationContext context; private List courses = new ArrayList(); @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.context = applicationContext; } @PostConstruct public void addCourse() { if (context.containsBean("math")) { Course math = context.getBean("math", Course.class); courses.add(math); } if (context.containsBean("physics")) { Course physics = context.getBean("physics", Course.class); courses.add(physics); } } // standard constructors, getters and setters }

Configurons le bean course et le bean enseignant dans classpathxmlapplicationcontext-example.xml :

Ensuite - testez l'injection de la propriété courses :

@Test public void testApplicationContextAware() { ApplicationContext context = new ClassPathXmlApplicationContext( "classpathxmlapplicationcontext-example.xml"); Teacher teacher = context.getBean("teacher", Teacher.class); List courses = teacher.getCourses(); assertThat(courses.size(), equalTo(1)); assertThat(courses.get(0).getName(), equalTo("math")); }

Outre l'implémentation de l' interface ApplicationContextAware , l'utilisation de l' annotation @Autowired a le même effet.

Changeons la classe des enseignants en ceci:

public class Teacher { @Autowired private ApplicationContext context; private List courses = new ArrayList(); @PostConstruct public void addCourse() { if (context.containsBean("math")) { Course math = context.getBean("math", Course.class); courses.add(math); } if (context.containsBean("physics")) { Course physics = context.getBean("physics", Course.class); courses.add(physics); } } // standard constructors, getters and setters }

Ensuite, exécutez ce test, nous pouvons voir que le résultat est le même.

5. Conclusion

ApplicationContext est un conteneur Spring avec des fonctionnalités plus spécifiques à l'entreprise par rapport à BeanFactory , et le ClassPathXmlApplicationContext est l'une de ses implémentations les plus couramment utilisées.

Donc, dans cet article, nous avons présenté plusieurs aspects du ClassPathXmlApplicationContext , y compris son utilisation de base, sa fonctionnalité d'enregistrement d'arrêt, sa fonctionnalité d'internationalisation et l'obtention de sa référence.

Comme toujours, le code source complet de l'exemple est disponible à l'adresse over sur GitHub.