Spring基本用法2——使用Spring容器(ApplicationContext)

最新推荐文章于 2023-01-03 11:33:09 发布
最新推荐文章于 2023-01-03 11:33:09 发布
阅读量1k 收藏
点赞数
分类专栏： Spring 文章标签： Spring容器 ApplicationContext 国际化 事件机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014240769/article/details/84904202
版权
本文介绍了Spring的ApplicationContext如何实现国际化支持和事件机制。通过配置ResourceBundleMessageSource，创建不同语言的资源文件，实现了根据不同地区显示对应语言的功能。此外，详细讲解了ApplicationContext的事件发布和监听，包括自定义事件、全局事件监听器的配置以及内置事件的说明。最后，展示了如何让Bean获取Spring容器，实现ApplicationContextAware接口以实现特定功能。
摘要由CSDN通过智能技术生成

        前言：Spring有两个核心接口(BeanFactory和ApplicationContext)，其中ApplicationContext是BeanFactory的子接口，它们都可以代表Spring容器，而Spring容器就是生成Bean实例的工厂，并管理容器中的Bean。而ApplicationContext作为功能更强大的Spring容器，提供了诸如资源访问(URL和文件)、事件机制、同时加载多个配置文件、国际化支持等扩展功能。因此，本文介绍在项目中常用到的功能模块

本篇文章重点关注以下问题：

  • ApplicationContext的国际化支持
  • ApplicationContext的事件机制
  • 在Bean中获取Spring容器

1. ApplicationContext的国际化支持

       ApplicationContext接口继承了MessageSource接口，因此具备了国际化功能。下面是MessageSource接口中定义的三个用于国际化的方法：

public interface MessageSource {
    /**
     * 尝试解析国际化信息，如果为找到相关国际化配置，则返回默认信息
     * @param code              待国际化信息在配置文件中的关键字
     * @param args              待国际化信息中占位符的值
     * @param defaultMessage    查找国家化配置失败后的默认返回值
     * @param locale            Locale信息
     * @return 
     */
    String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale);

    /**
     * 尝试解析国际化信息，如果为找到相关国际化配置，则返回null
     * @param code              待国际化信息在配置文件中的关键字
     * @param args              待国际化信息中占位符的值
     * @param locale            Locale信息
     * @return 
     */
    String getMessage(String code, @Nullable Object[] args, Locale locale) throws NoSuchMessageException;

    /**
     * 以国际化解析器进行国际化
     * @param resolvable        国际化解析接口
     * @param locale            Locale信息
     * @return 
     */
    String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException;
}
 
1.1 在Spring中配置MessageSource的Bean：通常使用ResourceBundleMessageSource类
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
                           
    <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
        <!-- 驱动Spring调用messageSource Bean的setBasenames()方法，该方法需要一个数组参数，使用list元素配置多个数组元素 -->
        <property name="basenames">
            <list>
                <value>com/wj/chapter2/applicationContextg/i18/message</value>
                <!-- 如果有多个资源文件，全部列在此处 -->
            </list>
        </property>
    </bean>
</beans>
      上面配置文件中的粗体字只指定了一份国际化资源文件，其baseName是message，然后给出它的两份资源文件：message_en_US.properties、message_zh_CN.properties。
 
1.2 生成资源文件(中式、美式)

      首先是美式资源文件：message_en_US.properties

hello=welcome,{0}
now=now is :{0}
      然后是中式资源文件：message_zh_CN.properties。 
hello=欢迎你,{0}
now=现在时间是 :{0}

     

       因为资源文件中含有简体中文，所以需要用native2ascii工具将这份资源文件国际化(native2ascii 源文件 目标文件)，得到的文件内容如下：

hello=\u6b22\u8fce\u4f60\uff0c{0}
now=\u73b0\u5728\u65f6\u95f4\u662f\uff1a{0}

      至此，程序就拥有了两份资源文件，可用于自适应美式英语和简体中文环境。

 
1.3 编写国际化功能测试代码
public class I18Main {
    
    // 1.指明xml配置文件位置，便于Spring读取，从而知道Bean的相关信息
    private static final String PATH_XML = "com/wj/chapter2/applicationContextg/i18/applicationContext.xml";
    
    @SuppressWarnings("resource")
    public static void main(String[] args)throws Exception {
        // 2.根据xml配置文件，创建Spring IOC容器的上下文
        ApplicationContext ctx = new ClassPathXmlApplicationContext(PATH_XML);
        // 3.使用getMessage()方法获取本地化消息。(Locale的getDefault方法返回计算机环境的默认Locale)
        String hello = ctx.getMessage("hello" , new String[]{"熊燕子"}, Locale.getDefault(Locale.Category.FORMAT));
        String now   = ctx.getMessage("now" , new Object[]{new Date()}, Locale.getDefault(Locale.Category.FORMAT));
        // 打印出两条本地化消息
        System.out.println(hello);
        System.out.println(now);
    }
}
 
1.4 查看运行结果

 

2. ApplicationContext的事件机制

        ApplicationContext的事件机制是典型的观察者设计模式，通过ApplicationEvent类和ApplicationListener接口，可以实现ApplicationContext的事件处理。如果容器中有一个ApplicationListener的Bean，每当ApplicationContext发布ApplicationEvent时，ApplicationListener的Bean都将自动触发。

       Spring的事件框架有如下两个重要成员：

  • ApplicationEvent：容器事件，必须由ApplicationContext发布。
  • ApplicationListener：监听器，可由容器中的任何监听器Bean担任。(必须实现ApplicationListener接口)
       实际上，Spring事件机制与所有的事件机制相似，都是由事件源、事件和事件监听组成，在Spring事件机制中，事件源是ApplicationContext，事件是ApplicationEvent的实现，监听器是ApplicationListener的实现。
2.1 首先定义一个Spring容器事件
/**
 * 定义容器事件，此事件必须由容器ApplicationContext发布
 * @author Administrator
 */
public class EmailEvent extends ApplicationEvent {
    private static final long serialVersionUID = 1259505481443188920L;
    
    private String address;
    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;
    }
    
    // setter|getter
    public String getAddress()             { return address;         }
    public String getText()                { return text;            }
    public void setAddress(String address) { this.address = address; }
    public void setText(String text)       { this.text = text;       }
}
        上面的EmailEvent类继承了ApplicationEvent，则该对象就可作为Spring容器的容器事件，便可通过容器发布。
 
2.2 实现容器事件的监听类

       容器事件的监听器必须实现ApplicationListener接口，并实现接口中的唯一方法：

@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {

	/**
	 * 每当容器内发生任何事件，此方法都会被触发.
	 * @param event the event to respond to
	 */
	void onApplicationEvent(E event);

}

       EmailEvent事件对应的监听器如下：

/**
 * 定义监听器，当事件发生时，通知所有观察者
 */
public class EmaiListener implements ApplicationListener<EmailEvent> {
    
    // 该方法会在容器发生事件时自动触发
    @Override
    public void onApplicationEvent(EmailEvent evt) {
        System.out.println("需要发送邮件的接收地址: " + evt.getAddress());
        System.out.println("需要发送邮件的邮件正文: " +  evt.getText());
    }
}
 
2.3 补充： 定义一个全局的事件监听器
/**
 * 通过此监听器可观察所有在Spring容器中定义的事件(泛型指定顶层接口)
 */
public class AllEventListener implements ApplicationListener<ApplicationEvent> {
    
    // 该方法会在容器发生事件时自动触发
    @Override
    public void onApplicationEvent(ApplicationEvent evt) {
        System.out.println("ApplicationEvent : " + evt);
    }
}

       利用泛型指定顶层ApplicationEvent类，关注所有发生的容器事件。

 
2.4 将监听器配置到xml配置文件中，以便容器知晓所有观察者(监听器)
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
                           
    <!-- 配置监听器(在Spring事件机制中，只需配置监听器即可) -->
    <bean class="com.wj.chapter2.applicationContextg.event.EmaiListener"/>
    <bean class="com.wj.chapter2.applicationContextg.event.AllEventListener"/>
</beans>

     从上面粗体字可看出，为Spring容器注册事件监听器，不需要像Swing编程那样采用代码进行编辑，只需在配置文件中简单说明即可。

 
2.5 通过ApplicationContext容器发布事件
public class EventTest {
    
    private static final String PATH_XML = "com/wj/chapter2/applicationContextg/event/applicationContext.xml";
    
    public static void main(String[] args) {
        /** 1.触发ContextRefreshedEvent事件. */
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(PATH_XML);
        
        // 创建一个ApplicationEvent对象
        EmailEvent emainEvent = new EmailEvent("test", "super_wj@163.com" , "this is a test");
        /** 2.触发EmailEvent事件. */
        ctx.publishEvent(emainEvent);
        
        /** 3.触发ContextClosedEvent事件. */
        ctx.close();
    }
}

       测试代码中会触发三个事件，两个容器自定义事件(ContextRefreshedEvent、ContextClosedEvent)，一个用户自定义事件(EmailEvent)事件。

 
2.6 观察测试结果输出

      如上图所示，可检测到三个事件的发布：ContextRefreshedEvent、EmailEvent、ContextClosedEvent。

 
2.7 补充说明Spring提供的内置事件
  1.  ContextRefreshedEvent：ApplicationContext容器初始化或刷新时触发该事件(如上面测试结果)。该事件触发说明ApplicationContext容器已就绪可用。
  2. ContextStartedEvent：当使用ConfigurableApplicationContext接口的start()方法启动ApplicationContext容器时触发该事件。
  3. ContextClosedEvent：当使用ConfigurableApplicationContext接口的close()方法关闭ApplicationContext容器时触发该事件(如上面测试结果)。
  4. ContextStoppedEvent：当使用ConfigurableApplicationContext接口的Stop()方法使ApplicationContext停止时触发该事件。
  5. RequestHandledEvent：Web相关的事件，只能应用于使用DispatcherServlet的Web、应用中，在使用SpringMVC作为前端的MVC控制器时，当Spring处理用户请求结束后，系统会自动触发该事件。
  6. 其他事件：Spring4.0.3后新增用于WebSocket的事件：SessionConnectedEvent、SessionConnectEvent、SessionDisconnectEvent

 3. 让Bean获取Spring容器

       前面的实例中，都是由程序显示的创建Spring容器，在这种访问模式下，程序中总是持有Spring容器的引用。但在Web应用中，Spring容器通常采用在web.xml中声明式方式配置产生，程序Bean处于容器管理之下，Bean无需主动访问容器。但是当需要借助Spring容器实现特定功能(如上述国际化、事件机制)时，就必须让Bean先获取Spring容器，然后借助Spring容器实现该功能。

       先设定需求：Person类sayHi(String name)方法必须能输出国际化消息，由于国际化功能需要借助于Spring容器实现，因此必须让Person获取到Spring容器对象，以便其拥有国际化的能力。

 
3.1 Person类实现ApplicationContextAware接口，并提供相应的setter方法

        为了让一个Bean获取它所在的Spring容器，可以让该Bean实现ApplicationContextAware接口，并复写接口里的唯一方法：

void setApplicationContext(ApplicationContext applicationContext) throws BeansException;

        这个方法将有Spring在创建该Bean对象时调用，以便在Spring容器调用该方法时，将容器自身作为参数传入该方法。

/**
 * 通过继承ApplicationContextAware接口，获取Application容器，从而调用国际化案例
 */
public class Person implements ApplicationContextAware {
    
    // 将BeanFactory容器以成员变量保存
    private ApplicationContext ctx;

    /**
     *  Spring容器会检测容器中所有Bean，如果发现某个Bean实现了
     *  ApplicationContextAware接口，Spring容器会在创建该Bean之后，
     *  Spring自动调用该Bean的setApplicationContext()方法，调用该方法时，
     *  Application会将容器本身作为参数传给该方法。
     */
    public void setApplicationContext(ApplicationContext ctx) throws BeansException {
        this.ctx = ctx;
    }
    
    public void sayHi(String name) {
        System.out.println(ctx.getMessage("hello" , new String[]{name}, Locale.getDefault(Locale.Category.FORMAT)));
    }
}
 
3.2 配置Spring配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

    <!-- 加载容器国际化所需要的语言资源文件 -->
    <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
        <property name="basenames">
            <list>
                <value>com/wj/chapter2/applicationContextg/i18/message</value>
            </list>
        </property>
    </bean>
    
    <!-- Spring容器会检测容器中所有Bean，如果发现某个Bean实现了
         ApplicationContextAware接口，Spring容器会在创建该Bean之后，
         Spring自动调用该Bean的setApplicationContext()方法，调用该方法时，
         Application会将容器本身作为参数传给该方法。-->
    <bean id="person" class="com.wj.chapter2.applicationContextg.ApplicationContextAware.Person"/>
</beans>

       由配置文件可以看出，配置Person对象Bean时，与配置其他Bean并没有区别。

 
3.3 编写测试程序
public class Main {
    
    // 1.指明xml配置文件位置，便于Spring读取，从而知道Bean的相关信息
    private static final String PATH_XML = "com/wj/chapter2/applicationContextg/ApplicationContextAware/applicationContext.xml";

    @SuppressWarnings("resource")
    public static void main(String[] args) {
        // 2.根据xml配置文件，创建Spring IOC容器的上下文
        ApplicationContext ctx = new ClassPathXmlApplicationContext(PATH_XML);
        
        // 3.获取Person对象，调用国际化功能
        ctx.getBean("person" , Person.class).sayHi("熊燕子");
    }

}
 
3.4 查看测试结果

      可以看出，的确安装资源文件的格式输出，说明Person类拿到ApplicationContext容器后具有了国际化能力。
 

 

代码下载地址：http://pan.baidu.com/s/1skOq7El，密码：qpi5

孤独的水手
关注
专栏目录
【Spring】——Spring的创建与使用
冷兮雪的博客
06-03 4961
上期我们讲解了Spring是什么及Spring的核心特点，其中重点讲解了控制反转（IoC）和依赖注入（DI），下面我们通过示例代码来去更深刻了解这其中的含义。
Spring源码——容器扩展ApplicationContext
等一杯咖啡的博客
10-06 4376
Spring源码——容器扩展ApplicationContext 前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第六章的部分，依照书中内容以及个人理解对Spring进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framewor...
spring中使用ApplicationContext
daoshud1的专栏
08-28 240
声明一个SpringUtil,并且实现ApplicationContextAware接口 private static ApplicationContext applicationContext; @Override public void setApplicationContext(ApplicationContext context) t
Spring之ApplicationContext快速入门
最新发布
qq_61313896的博客
01-03 596
Spring之ApplicationContext快速入门
Spring ApplicationContext 容器
QAQ123666的博客
04-06 197
ApplicationContext 容器 Application Context 是 BeanFactory 的子接口，也被称为 Spring 上下文。 Application Context 是 spring 中较高级的容器。和 BeanFactory 类似，它可以加载配置文件中定义的 bean，将所有的 bean 集中在一起，当有请求的时候分配 bean。 另外，它增加了企业所需要的功能，比...
ApplicationContext用法示例
weixin_30588675的博客
05-04 659
1、通过ApplicationContext将bean注入容器中 import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframewor...
spring获取ApplicationContext对象的方法
shyboy0358的专栏
12-27 148
方法一：在初始化时保存ApplicationContext对象 代码： ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml"); ac.getBean("beanId"); 说明：这种方式适用于采用Spring框架的独立应用程序，需要程序通过配置文件手工初始化Spring的情...
三、Spring源码分析——ApplicationContext
08-11
总的来说，ApplicationContext作为Spring的核心组件，扮演着应用程序的“大脑”角色，它负责管理和协调整个Spring容器中的Bean。理解并掌握ApplicationContext的工作原理和使用技巧，对于深度开发和优化Spring应用至...
Spring源码私家笔记—— ApplicationContext.refresh()方法浅析
mytream的专栏
05-04 863
从本章开始我们将开始进入Spring容器真正的刷新启动过程，直接点击或者debugger进入AbstractApplicationContext的refresh()方法。这里再次提示一下大家，在先前的提到过的“胸有大纲，心中不慌”，大家务必要克制自己挨个debugger进refresh的每个方法进行查看的冲动。 大家想啊，Spring的作者把一个个的对象和方法封装出来，就是想要屏蔽底层实现的复杂性，那我们就按照这一个个方法名先理解个大概。建议大家直接把springframework的官方源码clone下来，
Spring————面试题库
03-04
使用Spring框架能够为开发者带来许多好处，例如通过依赖注入（Dependency Injection, DI）方法，能够清晰地管理对象间的依赖关系，相比于EJB容器，Spring的IoC容器更为轻量级，更适合在有限的内存和CPU资源下进行...
获取spring容器applicationContext的几种方式
gaozzsoft的专栏
04-13 131
  一、定义web.xml，由web容器自动加载配置文件初始化ApplicationContext实例，用WebApplicationContextUtils.getWebApplicationContext()得到ApplicationContext的引用。 方法1(web.xml) &lt;web-app&gt;    &lt;context-param&gt;       &lt;par...
Spring(2)--使用Spring容器
Runner的博客
03-28 497
Spring有两个核心接口：BeanFactory和ApplicationContext，其中ApplicationContext是BeanFactory的子接口。它们都可代表Spring容器，Spring是生成Bean实例的工厂，并管理容器中的Bean。
采用dom4j和反射模拟Spring框架的依赖注入功能
weixin_30628801的博客
11-04 135
　　Spring的依赖注入是指将对象的创建权交给Spring框架,将对象所依赖的属性注入进来的行为.在学习了dom4j后,其实也可以利用dom4j和反射做一个小Demo模拟Spring框架的这种功能.下面是具体的步骤: 　　第一步,编写配置文件.配置文件的书写,采用了和Spring的配置文件applicationContext.xml一样的书写规则: <?xml version="1...
spring学习之---使用spring容器
StrongHYQ的博客
07-21 342
spring有两个核心接口:BeanFactory和ApplicationContext，其中ApplicationContext是BeanFactory的子接口。它们都可代表spring容器，spring容器是生成Bean实例的工厂，并管理容器中的Bean，所有的组件都被当成Bean处理。 1.Spring容器 spring容器最基本的接口是BeanFactory，BeanFactory负
spring容器之ApplicationContext
冷月的编程学习
05-16 5万+
一、ApplicationContext：是spring继BeanFactory之外的另一个核心接口或容器，允许容器通过应用程序上下文环境创建、获取、管理bean。为应用程序提供配置的中央接口。在应用程序运行时这是只读的，但如果实现支持这一点，则可以重新加载。 一个ApplicationContext提供: •访问应用程序组件的Bean工厂方法。从org.springframework.bea...
Spring--ApplicationContext--使用/教程/原理
IT利刃出鞘的博客
11-17 5455
本文介绍Spring中的ApplicationContext的用法、原理。包含：BeanFactory与ApplicationContext的区别，包装为工具类（静态获取Bean），getBean()与@Autowired异同。 ApplicationContext继承了BeanFactory接口，它持有Spring应用的上下文，通过它，我们可以：国际化（MessageSource）；访问资源（ResourceLoader）如：URL和文件；载入应用上下文；使用事件机制............
spring项目中获取ApplicationContext对象，然后手动获取bean
热门推荐
点滴之路
09-17 9万+
   在服务器启动过程中，spring容器也会初始化，那么当然，Spring的ApplicationContext对象肯定也在这个过程中会被初始化了，那么我们如何在java类中手动去获取得到这个对象呢？    首先， 我们为什么要去获取这个ApplicationContext对象？，获取到了我们能干什么呢？ -- 能手动从Spring获取所需要的bean // 获取bean 方法1 publ...
springboot 注入ApplicationContext成功(ApplicationContextAware),获取时为null的解决
a1091662876的博客
06-27 2万+
正常情况下如下代码即可注入并获取到applicationContext 只要注意,如果是springmvc需要配置包扫描且配置的包包含该工具类所在的包 <context:component-scan base-package="com.XXX"></context:component-scan> 如果是通过XML配置bean则需要放在最前 <bean id="...
红帽考试资料_冰山一角
weixin_51014063的博客
09-28 556
之更新（容器） 运行一个基本的容器 查找容器的映像 为容器通过永久存储 容器技术的介绍：为什么要用容器 RPM有依赖关系，当安装httpd包的时候，RPM包会确保安装正确的库和依赖项。容器的内容是隔离的，互相不影响。 传统虚拟化：需要安装底层的环境，而容器的不需要安装底层的环境 容器和虚拟机与硬件和底层操作系统的交互方式不同 虚拟化： 可以在单一硬件平台运行多个操作系统 容器： 在操作系统中直接运行，容器之间分享硬件和操作系统的资源，容器中应用中轻量化和快速并行启动 容器是一个没有灵魂的虚拟机 容器的核心技
Spring容器后处理器详解与应用
然而，如果选择使用基本的BeanFactory，那么就需要手动调用`registerBeanPostProcessor()`方法来注册后处理器。 使用Spring容器后处理器的一个常见场景是在Spring XML配置文件中不能直接表达的复杂配置，例如，动态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值