streamalism.org

1. Overzicht

De Spring Framework-kern is, simpel gezegd, een IoC-container die wordt gebruikt om bonen te beheren.

Er zijn twee basistypen containers in Spring: de Bean Factory en de Application Context. De eerste biedt basisfunctionaliteiten, die hier worden geïntroduceerd; de laatste is een superset van de eerste en wordt het meest gebruikt.

ApplicationContext is een interface in het org.springframework.context pakket en het heeft verschillende implementaties, en het ClassPathXmlApplicationContext is er een van.

In dit artikel zullen we ons concentreren op de nuttige functionaliteiten die worden geboden door het ClassPathXmlApplicationContext.

2. Basisgebruik

2.1. Initialiseer container en beheer bonen

ClassPathXmlApplicationContext kan een XML-configuratie laden vanuit een klassenpad en zijn bonen beheren:

We hebben een Leerling klasse:

openbare klas Student {privé int no; private String naam; // standaard constructeurs, getters en setters}

We configureren een Leerling bonen in classpathxmlapplicationcontext-example.xml en voeg het toe aan een klassenpad:

Nu kunnen we de ClassPathXmlApplicationContext om de XML-configuratie te laden en het Leerling Boon:

@Test openbare ongeldige 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. Meerdere XML-configuraties

Soms willen we verschillende XML-configuraties gebruiken om een ​​Spring-container te initialiseren. In dat geval hoeven we alleen maar verschillende configuratielocaties toe te voegen bij het construeren van het ApplicationContext:

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

3. Extra mogelijkheden

3.1. Sluit de Spring IoC-container sierlijk af

Wanneer we Spring IoC-container gebruiken in een webapplicatie, is Spring webgebaseerd ApplicationContext implementaties sluiten de container netjes af wanneer de applicatie wordt afgesloten, maar als we deze gebruiken in een niet-webomgeving, zoals een zelfstandige desktopapplicatie, moeten we zelf een shutdown hook registreren bij de JVM om er zeker van te zijn dat de Spring IoC-container wordt netjes afgesloten en roept de vernietigingsmethoden aan om bronnen vrij te geven.

Laten we een vernietigen() methode naar de Leerling klasse:

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

We kunnen deze methode nu configureren als de leerling Bean's vernietigingsmethode:

We zullen nu een shutdown-hook registreren:

@Test openbare ongeldige testRegisterShutdownHook () {ConfigurableApplicationContext context = nieuwe ClassPathXmlApplicationContext ("classpathxmlapplicationcontext-example.xml"); context.registerShutdownHook (); }

Wanneer we de testmethode uitvoeren, kunnen we het vernietigen() methode wordt genoemd.

3.2. Internationalisering met MessageSource

De ApplicationContext interface breidt de MessageSource interface, biedt daarom internationaliseringsfunctionaliteit.

Een ApplicationContext container zoekt automatisch naar een MessageSource bean bij de initialisatie, en de bean moet de naam hebben messageSource.

Hier is een voorbeeld van het gebruik van verschillende talen met MessageSource:

Laten we eerst een dialoog map in een klassenpad en voeg twee bestanden toe aan de dialoogmap: dialog_nl.properties en dialog_zh_CN.properties.

dialog_nl.properties:

hallo = hallo jij = jij bedankt = bedankt {0}

dialog_zh_CN.properties:

hallo = \ u4f60 \ u597d jij = \ u4f60 bedankt = \ u8c22 \ u8c22 {0}

Configureer het messageSource bonen in classpathxmlapplicationcontext-internationalization.xml:

    dialoog / dialoog 

Laten we vervolgens de dialoogwoorden van verschillende talen krijgen met MessageSource:

@Test public void testInternationalization () {MessageSource resources = new ClassPathXmlApplicationContext ("classpathxmlapplicationcontext-internationalization.xml"); String enHello = resources.getMessage ("hallo", null, "Default", Locale.ENGLISH); String enYou = resources.getMessage ("jij", null, Locale.ENGLISH); String enThanks = resources.getMessage ("thanks", new Object [] {enYou}, Locale.ENGLISH); assertThat (enHallo, gelijk aan ("hallo")); assertThat (enThanks, equalTo ("dank u")); String chHello = resources.getMessage ("hallo", null, "Default", Locale.SIMPLIFIED_CHINESE); String chYou = resources.getMessage ("jij", null, Locale.SIMPLIFIED_CHINESE); String chThanks = resources.getMessage ("thanks", new Object [] {chYou}, Locale.SIMPLIFIED_CHINESE); assertThat (chHello, equalTo ("你്")); assertThat (chThanks, equalTo ("谢谢 你")); }

4. Een verwijzing naar het ApplicationContext

Soms hebben we de referentie nodig van ApplicationContext in de bonen die erdoor worden beheerd, kunnen we gebruiken ApplicationContextAware of @Autowired om dit te doen. Laten we eens kijken hoe u ApplicationContextAware werken:

We hebben een Cursus klas met een naam:

openbare klas Cursus {privé Stringnaam; // standaard constructeurs, getters en setters}

We hebben een Leraar klasse die zijn cursussen samenstelt volgens de bonen van de container:

openbare klasse Leraar implementeert ApplicationContextAware {privé ApplicationContext-context; privélijstcursussen = nieuwe ArrayList (); @Override public void setApplicationContext (ApplicationContext applicationContext) gooit BeansException {this.context = applicationContext; } @PostConstruct public void addCourse () {if (context.containsBean ("math")) {Course math = context.getBean ("math", Course.class); cursussen.add (wiskunde); } if (context.containsBean ("fysica")) {Cursus fysica = context.getBean ("fysica", Course.class); courses.add (natuurkunde); }} // standaard constructeurs, getters en setters}

Laten we het Cursus boon en de leraar bonen in classpathxmlapplicationcontext-example.xml:

Test vervolgens de injectie van de cursussen eigendom:

@Test openbare ongeldige testApplicationContextAware () {ApplicationContext context = new ClassPathXmlApplicationContext ("classpathxmlapplicationcontext-example.xml"); Leraar leraar = context.getBean ("leraar", Teacher.class); Lijst met cursussen = teacher.getCourses (); assertThat (courses.size (), equalTo (1)); assertThat (courses.get (0) .getName (), equalTo ("math")); }

Naast het implementeren van het ApplicationContextAware interface, met behulp van de @Autowired annotatie heeft hetzelfde effect.

Laten we de Leraar klasse naar dit:

openbare klas Docent {@Autowired privé ApplicationContext-context; privélijstcursussen = nieuwe ArrayList (); @PostConstruct public void addCourse () {if (context.containsBean ("math")) {Course math = context.getBean ("math", Course.class); cursussen.add (wiskunde); } if (context.containsBean ("fysica")) {Cursus fysica = context.getBean ("fysica", Course.class); courses.add (natuurkunde); }} // standaard constructeurs, getters en setters}

Voer vervolgens die test uit, we kunnen zien dat het resultaat hetzelfde is.

5. Conclusie

ApplicationContext is een Spring container met meer bedrijfsspecifieke functionaliteiten in vergelijking met BeanFactory, en de ClassPathXmlApplicationContext is een van de meest gebruikte implementaties.

Daarom hebben we in dit artikel verschillende aspecten van de ClassPathXmlApplicationContext, inclusief het basisgebruik, de afsluitregistratiefunctie, de internationaliseringsfunctionaliteit en het verkrijgen van de referentie.

Zoals altijd is de volledige broncode voor het voorbeeld beschikbaar op GitHub.