Spring之ClassPathXmlApplicationContext

Spring之ClassPathXmlApplicationContext

听说转发文章

会给你带来好运

1

介绍

简单地说，Spring Framework核心是一个用于管理bean的IoC容器。

Spring中有两种基本类型的容器 - Bean Factory和Application Context。 前者提供了基本功能，在此介绍; 后者是前者的超集，是最广泛使用的。

ApplicationContext是org.springframework.context包中的一个接口，它有几个实现，ClassPathXmlApplicationContext就是其中之一。

在本文中，我们将重点介绍ClassPathXmlApplicationContext提供的有用功能。

2

基本用法

2.1 初始化容器和管理Bean

ClassPathXmlApplicationContext可以从类路径加载XML配置并管理其bean。

我们有一个Student类：

1. public class Student {
2. private int no;
3. private String name;
4. // standard constructors, getters and setters
5. }

我们在classpathxmlapplicationcontext-example.xml中配置Student bean并将其添加到类路径中：

1. <beans ...>
2. <bean id="student" class="com.baeldung.applicationcontext.Student">
3. <property name="no" value="15"/>
4. <property name="name" value="Tom"/>
5. </bean>
6. </beans>

现在我们可以使用ClassPathXmlApplicationContext来加载XML配置并获取Student bean：

1. @Test
2. public void testBasicUsage() {
3. ApplicationContext context
4. = new ClassPathXmlApplicationContext(
5. "classpathxmlapplicationcontext-example.xml");
6. Student student = (Student) context.getBean("student");
7. assertThat(student.getNo(), equalTo(15));
8. assertThat(student.getName(), equalTo("Tom"));
9. Student sameStudent = context.getBean("student", Student.class);
10. assertThat(sameStudent.getNo(), equalTo(15));
11. assertThat(sameStudent.getName(), equalTo("Tom"));
12. }

2.2 多个XML配置

有时我们想使用几个XML配置来初始化Spring容器。 在这种情况下，我们只需要在构造ApplicationContext时添加几个配置位置：

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

3

附加功能

3.1 优雅关闭Spring IOC容器

当我们在Web应用程序中使用Spring IoC容器时，Spring的基于Web的ApplicationContext实现将在关闭应用程序时正常关闭容器，但如果我们在非Web环境中使用它，

例如独立的桌面应用程序，我们我们必须自己向JVM注册一个关闭钩子，以确保Spring IoC容器正常关闭并调用destroy方法释放资源。

在Student类中添加一个destroy()方法：

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

我们现在可以将此方法配置为student bean的destroy方法：

1. <beans ...>
2. <bean id="student" class="com.baeldung.applicationcontext.Student"
3. destroy-method="destroy">
4. <property name="no" value="15"/>
5. <property name="name" value="Tom"/>
6. </bean>
7. </beans>

我们现在将注册一个关闭钩子：

1. @Test
2. public void testRegisterShutdownHook() {
3. ConfigurableApplicationContext context
4. = new ClassPathXmlApplicationContext(
5. "classpathxmlapplicationcontext-example.xml");
6. context.registerShutdownHook();
7. }

当我们运行测试方法时，我们可以看到调用destroy()方法。

3.2 使用MessageSource进行国际化

ApplicationContext接口扩展了MessageSource接口，因此提供了国际化功能。

ApplicationContext容器在其初始化时自动搜索MessageSource bean，并且bean必须命名为messageSource。

以下是使用MessageSource使用不同语言的示例。

首先，让我们将一个会话目录添加到类路径中，并将两个文件添加到会话目录中：dialog_en.properties和dialog_zh_CN.properties。

dialog_en.properties:

1. hello=hello
2. you=you
3. thanks=thank {0}

dialog_zh_CN.properties:

1. hello=\\u4f60\\u597d
2. you=\\u4f60
3. thanks=\\u8c22\\u8c22{0}

在classpathxmlapplicationcontext-internationalization.xml中配置messageSource bean：

1. <beans ...>
2. <bean id="messageSource"
3. class="org.springframework.context.support.ResourceBundleMessageSource">
4. <property name="basenames">
5. <list>
6. <value>dialog/dialog</value>
7. </list>
8. </property>
9. </bean>
10. </beans>

然后，让我们使用MessageSource获取不同语言的对话框：

1. @Test
3. public void testInternationalization() {
4. MessageSource resources
5. = new ClassPathXmlApplicationContext(
6. "classpathxmlapplicationcontext-internationalization.xml");
7. String enHello = resources.getMessage(
8. "hello", null, "Default", Locale.ENGLISH);
9. String enYou = resources.getMessage(
10. "you", null, Locale.ENGLISH);
11. String enThanks = resources.getMessage(
12. "thanks", new Object[] { enYou }, Locale.ENGLISH);
13. assertThat(enHello, equalTo("hello"));
14. assertThat(enThanks, equalTo("thank you"));
15. String chHello = resources.getMessage(
16. "hello", null, "Default", Locale.SIMPLIFIED_CHINESE);
17. String chYou = resources.getMessage(
18. "you", null, Locale.SIMPLIFIED_CHINESE);
19. String chThanks = resources.getMessage(
20. "thanks", new Object[] { chYou }, Locale.SIMPLIFIED_CHINESE);
21. assertThat(chHello, equalTo("你好"));
22. assertThat(chThanks, equalTo("谢谢你"));
23. }

4

ApplicationContext引用

有时我们需要在由它管理的bean中获取ApplicationContext的引用，我们可以使用ApplicationContextAware或@Autowired来执行此操作。

让我们看看如何使用ApplicationContextAware：

1. public class Course {
2. private String name;
3. // standard constructors, getters and setters
4. }

我们有一个Teacher类，它根据容器的bean组装它的课程：

1. public class Teacher implements ApplicationContextAware {
2. private ApplicationContext context;
3. private List<Course> courses = new ArrayList<>();
4. @Override
5. public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
6. this.context = applicationContext;
7. }
8. @PostConstruct
9. public void addCourse() {
10. if (context.containsBean("math")) {
11. Course math = context.getBean("math", Course.class);
12. courses.add(math);
13. }
14. if (context.containsBean("physics")) {
15. Course physics = context.getBean("physics", Course.class);
16. courses.add(physics);
17. }
18. }
19. // standard constructors, getters and setters
20. }

在classpathxmlapplicationcontext-example.xml中配置课程bean和教师bean：

1. <beans ...>
2. <bean id="math" class="com.baeldung.applicationcontext.Course">
3. <property name="name" value="math"/>
4. </bean>
5. <bean name="teacher" class="com.baeldung.applicationcontext.Teacher"/>
6. </beans>

然后，测试课程属性的注入：

1. @Test
2. public void testApplicationContextAware() {
3. ApplicationContext context
4. = new ClassPathXmlApplicationContext(
5. "classpathxmlapplicationcontext-example.xml");
6. Teacher teacher = context.getBean("teacher", Teacher.class);
7. List<Course> courses = teacher.getCourses();
8. assertThat(courses.size(), equalTo(1));
9. assertThat(courses.get(0).getName(), equalTo("math"));
10. }

除了实现ApplicationContextAware接口之外，使用@Autowired注释也具有相同的效果。

将Teacher类更改为：

1. public class Teacher {
2. @Autowired
3. private ApplicationContext context;
4. private List<Course> courses = new ArrayList<>();
5. @PostConstruct
6. public void addCourse() {
7. if (context.containsBean("math")) {
8. Course math = context.getBean("math", Course.class);
9. courses.add(math);
10. }
11. if (context.containsBean("physics")) {
12. Course physics = context.getBean("physics", Course.class);
13. courses.add(physics);
14. }
15. }
16. // standard constructors, getters and setters
17. }

然后运行测试用例，我们可以看到结果是一样的。

总结

ApplicationContext是一个Spring容器，与BeanFactory相比具有更多特定于企业应用的功能，而ClassPathXmlApplicationContext是其最常用的实现之一。

因此，在本文中，我们介绍了ClassPathXmlApplicationContext的几个方面，包括其基本用法，关闭注册功能，国际化功能以及获取其引用。