Einführung in den Spring ClassPathXmlApplicationContext

1. Übersicht

Der Spring Framework-Kern ist einfach ausgedrückt ein IoC-Container, der zum Verwalten von Beans verwendet wird.

Im Frühjahr gibt es zwei grundlegende Arten von Containern: die Bean Factory und den Anwendungskontext. Ersteres bietet grundlegende Funktionen, die hier vorgestellt werden. Letzteres ist eine Obermenge des ersteren und wird am häufigsten verwendet.

ApplicationContext ist eine Schnittstelle im Paket org.springframework.context und verfügt über mehrere Implementierungen. Der ClassPathXmlApplicationContext ist eine davon.

In diesem Artikel konzentrieren wir uns auf die nützlichen Funktionen des ClassPathXmlApplicationContext .

2. Grundlegende Verwendung

2.1. Container initialisieren und Bohnen verwalten

ClassPathXmlApplicationContext kann eine XML-Konfiguration aus einem Klassenpfad laden und seine Beans verwalten:

Wir haben eine Schülerklasse :

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

Wir konfigurieren eine Student- Bean in classpathxmlapplicationcontext-example.xml und fügen sie einem Klassenpfad hinzu:

Jetzt können wir den ClassPathXmlApplicationContext verwenden , um die XML-Konfiguration zu laden und die Student- Bean abzurufen :

@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. Mehrere XML-Konfigurationen

Manchmal möchten wir mehrere XML-Konfigurationen verwenden, um einen Spring-Container zu initialisieren. In diesem Fall müssen wir beim Erstellen des ApplicationContext lediglich mehrere Konfigurationsspeicherorte hinzufügen :

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

3. Zusätzliche Funktionen

3.1. Schalten Sie den Spring IoC Container ordnungsgemäß aus

Wenn wir den Spring IoC-Container in einer Webanwendung verwenden, wird der Container durch die webbasierten ApplicationContext- Implementierungen von Spring ordnungsgemäß heruntergefahren, wenn die Anwendung heruntergefahren wird. Wenn wir ihn jedoch in einer Nicht-Web-Umgebung wie einer eigenständigen Desktop-Anwendung verwenden, werden wir Sie müssen selbst einen Shutdown-Hook bei der JVM registrieren, um sicherzustellen, dass der Spring IoC-Container ordnungsgemäß heruntergefahren wird, und die Destroy-Methoden aufrufen, um Ressourcen freizugeben.

Fügen wir der Student- Klasse eine destroy () -Methode hinzu :

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

Wir können diese Methode jetzt als Zerstörungsmethode der Student Bean konfigurieren :

Wir werden jetzt einen Shutdown-Hook registrieren:

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

Wenn wir die Testmethode ausführen, können wir sehen, dass die destroy () -Methode aufgerufen wird.

3.2. Internationalisierung mit MessageSource

Die ApplicationContext- Schnittstelle erweitert die MessageSource- Schnittstelle und bietet daher Internationalisierungsfunktionen.

Ein ApplicationContext- Container sucht bei seiner Initialisierung automatisch nach einer MessageSource- Bean, und die Bean muss als messageSource benannt werden .

Hier ist ein Beispiel für die Verwendung verschiedener Sprachen mit MessageSource :

Fügen wir zunächst ein Dialogverzeichnis zu einem Klassenpfad hinzu und fügen dem Dialogverzeichnis zwei Dateien hinzu: dialog_en.properties und 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}

Konfigurieren Sie die messageSource- Bean in classpathxmlapplicationcontext -internationalization.xml :

    dialog/dialog    

Lassen Sie uns dann die Dialogwörter verschiedener Sprachen mit MessageSource abrufen :

@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. Ein Verweis auf den ApplicationContext

Manchmal müssen wir die Referenz von ApplicationContext in den von ihm verwalteten Beans abrufen . Dazu können wir ApplicationContextAware oder @Autowired verwenden. Mal sehen, wie die Verwendung von ApplicationContextAware funktioniert:

Wir haben eine Kursklasse mit einem Namen:

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

Wir haben eine Lehrerklasse , die ihre Kurse nach den Bohnen des Containers zusammenstellt:

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 }

Konfigurieren wir die Kurs- Bean und die Lehrer- Bean in classpathxmlapplicationcontext-example.xml :

Dann - testen Sie die Injektion der Kurseigenschaft :

@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")); }

Neben der Implementierung der ApplicationContextAware- Schnittstelle hat die Verwendung der Annotation @Autowired den gleichen Effekt.

Lassen Sie uns die Lehrerklasse folgendermaßen ändern :

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 }

Führen Sie dann diesen Test durch. Wir können sehen, dass das Ergebnis dasselbe ist.

5. Schlussfolgerung

ApplicationContext ist ein Spring-Container mit unternehmensspezifischeren Funktionen im Vergleich zu BeanFactory , und der ClassPathXmlApplicationContext ist eine der am häufigsten verwendeten Implementierungen.

In diesem Artikel haben wir verschiedene Aspekte des ClassPathXmlApplicationContext vorgestellt , einschließlich seiner grundlegenden Verwendung, seiner Registrierungsfunktion zum Herunterfahren, seiner Internationalisierungsfunktion und des Abrufs seiner Referenz.

Wie immer ist der vollständige Quellcode für das Beispiel auf GitHub verfügbar.