Spring中的容器

1.Spring容器

Spring容器最基本的接口就是BeanFactory, 负责配置，创建和管理bean。我们通常不直接使用BeanFactory接口，而是使用其子接口ApplicationContext.

接口ApplicationContext常用实现类是FileSystemXmlApplicationContext和ClassPathXmlApplicationContext等。后者最常用。

ApplicationContext的实例就是一个容器，Spring容器的意义在于创建和初始化类对象，管理类的依赖关系。

2.ApplicationContext的事件机制

AppicationContext的事件机制是观察者模式的实现，按以下方式可以实现。

首先我们需要自定义一个事件类，此事件类是需要继承ApplicationEvent类
然后我们定义一个监听类，监听类作为一个Spring容器中的bean，同时需要实现ApplicationListner接口
然后我们就可以使用ApplicationContext的实例发布事件，相应监听类的实例（bean）负责监听具体的事件

下面是一个简单的例子，

事件类，必须继承ApplicationEvent，是否为Spring容器的bean无所谓，

 package spi;

 import org.springframework.context.ApplicationEvent;

 public class EmailEvent extends ApplicationEvent {

     private String address;

     public String getAddress() {

         return address;

     }

     public void setAddress(String address) {

         this.address = address;

     }

     public String getText() {

         return text;

     }

     public void setText(String text) {

         this.text = text;

     }

     private String text;

     public EmailEvent(Object source) {

         super(source);

     }

     public EmailEvent(Object source, String address, String text) {

         super(source);

         this.address =  address;

         this.text = text;

     }

 }

监听类，必须作为Spring容器的bean，同时需要实现ApplicationListener接口，重写onApplicationEvent方法

 package spi;

 import org.springframework.context.ApplicationEvent;

 import org.springframework.context.ApplicationListener;

 public class EmailNotifier implements ApplicationListener {

     @Override

     public void onApplicationEvent(ApplicationEvent evt) {

         if (evt instanceof EmailEvent) {

             EmailEvent emailEvent = (EmailEvent)evt;

             System.out.println("邮件地址："+emailEvent.getAddress());

             System.out.println("邮件内容："+emailEvent.getText());

         } else {

             System.out.println("其他事件："+evt);

         }

     }

 }

将监听类配置进Spring容器配置文件中，并没有什么特殊之处，

<bean class="spi.EmailNotifier" />

下面写一个测试类，

     public static void test2() {

         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

         EmailEvent ele = new EmailEvent("test", "test@test.com", "this is a test");

         ctx.publishEvent(ele);

     }

执行测试类，发现我们不仅监听到了想要监听的事件EmailEvent，同时还有一个系统事件ContextRefreshedEvent也被监听到了，输出如下，

 其他事件：org.springframework.context.event.ContextRefreshedEvent[source=org.springframework.context.support.ClassPathXmlApplicationContext@1873eb2: startup date [Fri Feb 03 01:19:21 CST 2017]; root of context hierarchy]

 邮件地址：test@test.com

 邮件内容：this is a test

3.ApplicationContext的国际化支持

ApplicationContext接口继承了MessageSource接口，因此具有国际化功能。MessageSource接口提供了getMessage(...)方法用来进行字符串转换。

Spring要实现国际化，需要将MessageSource的实例配置成Spring容器中的bean，在bean的属性（即依赖注入）中配置国际化文件，

     <!-- ApplicationContext的实例将会查找是否有messageSource的实例并初始化它 -->

     <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">

         <!-- 这里即依赖注入 -->

         <property name="basenames">

             <list>

             <!-- 在这里添加国际化配置文件 -->

                 <value>message</value>

             </list>

         </property>

     </bean>

为此我们需要创建两份国际化配置文件，第一份为英语，文件名 message_en_US.properties，内容如下，

 str1=welcome,{0}

 str2=now is : {0}

第二份为中文，文件名为message.properties，内容如下，

 str1=欢迎，{0}

 str2=现在时间是：{0}

由于这个文件包含了非西欧字符，因此我们用java自带的native2ascii进行转换，命令为

 cd C:\Program Files (x86)\Java\jdk1..0_79\bin\

 native2ascii C:\PROJECT\JavaBasic\PROJECT_JavaBasic\src\message.properties C:\PROJECT\JavaBasic\PROJECT_JavaBasic\src\message_zh_CN.properties

转换后得到message_zh_CN.properties文件即可。

接着写一个测试类，

     public static void test3() {

         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

         String str1 = ctx.getMessage("str1", new String[]{"孙悟空"},

                 Locale.getDefault(Locale.Category.FORMAT));

         String str2 = ctx.getMessage("str2", new Object[]{new Date()},

                 Locale.getDefault(Locale.Category.FORMAT));

         System.out.println(str1);

         System.out.println(str2);

         String str3 = ctx.getMessage("str1", new String[]{"孙悟空"},

                 Locale.US);

         String str4 = ctx.getMessage("str2", new Object[]{new Date()},

                 Locale.US);

         System.out.println(str3);

         System.out.println(str4);

     }

我们分别在中文环境和英文环境测试了两个字符串str1和str2，得到结果如下，

 欢迎，孙悟空

 现在时间是：17-2-3 上午1:31

 welcome,孙悟空

 now is : 2/3/17 1:31 AM

上面的文字“孙悟空”因为是直接写在代码里面，不属于properties配置文件的，因此在中英文结果都保留原来的文字。

4.让Bean获取Spring容器

如果需要让Bean主动获取它所在的Spring容器的引用，可以让该Bean实现BeanFactoryAware接口，并实现setBeanFactory(BeanFactory beanFactory)方法。

下面是一个例子，

 package spi;

 import java.util.Locale;

 import org.springframework.beans.BeansException;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.ApplicationContextAware;

 public class GetContextViaBean implements ApplicationContextAware {

     private ApplicationContext ctx;

     @Override

     public void setApplicationContext(ApplicationContext ctx)

             throws BeansException {

         this.ctx = ctx;

     }

     public void SayHi(String name) {

         System.out.println(ctx.getMessage("str1", new String[]{name}, Locale.US));

     }

 }

将这个类作为一个普通bean配置进Spring中，

<bean id="getContextViaBean" class="spi.GetContextViaBean" />

下面写一个测试类，来实现前面的国际化的功能，

     public static void test4() {

         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

         GetContextViaBean bean = ctx.getBean("getContextViaBean", GetContextViaBean.class);

         bean.SayHi("孙悟空");

     }

执行结果为，

 welcome,孙悟空

与前面国际化方式相比，其实本质上没有区别，只不过前面的国际化是在测试类中，直接使用ApplicationContext的实例调用MessageSource的getMessage()方法，

而这里是在Bean中，主动去获取所在容器(ApplicationContext)的引用，并在beanzhong通过ApplicationContext的引用调用了MessageSource的getMessage()方法。

巴特西

Spring中的容器

1.Spring容器

2.ApplicationContext的事件机制

3.ApplicationContext的国际化支持

4.让Bean获取Spring容器

最新文章

热门文章