首页 > 软件编程 > java > ApplicationContext的拓展功能

Spring中ApplicationContext的拓展功能详解

2024-01-08 09:06:27 作者：猎户星座。

这篇文章主要介绍了Spring中ApplicationContext的拓展功能详解,相对于BeanFactory来说,ApplicationContext除了提供BeanFactory的所有功能外,还有一些其他的功能,主要包括国际化支持、资源访问、事件传递,需要的朋友可以参考下

国际化支持

简介

国际化的英文为Internationalization，这个也太长了，所以它又称为I18n(英文单词 internationalization的首末字符i和n，18为中间的字符数)。国际化的操作就是指一个程序可以同时适应多门语言，即：如果现在程序的使用者是中国人，则会以中文为显示文字，如果现在程序的使用者是美国人，则会以英语为显示的文字，也就是说可以通过国际化操作，让一个程序适应各个国家的语言要求。

原理

程序根据不同的语言环境找到不同的资源文件，之后从资源文件中取出内容，资源文件中的内容是以key-àvalue的形式保存的，所以在读取的时候通过其key找到对应的value

Demo

1、i18n.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" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
 
	<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
        <property name="basenames">
            <list>
                <value>message</value>
            </list>
        </property>
</bean>
</beans>

2、message_en_US.properties

k1=welcome\uFF1A {0}

3、message_zh_CN.properties

k1=\u6b22\u8fce\u4f60\uff0c{0}

k1就是“你好”，上面使用的是unicode。可以使用Unicode的转换器来进行转换，也可以使用命令

4、测试

package com.yj.spring;
 
import java.util.Locale;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class I18NTest {
 
	@Test
	public void Test() {
		Locale defaultLocale = Locale.getDefault();
		//Locale defaultLocale = Locale.US;
		System.out.println("country="+ defaultLocale.getCountry());
	    System.out.println("language="+ defaultLocale.getLanguage());
 
		Object[] arg = new Object[] { "悟空"};
		ApplicationContext ctx = new ClassPathXmlApplicationContext("i18n.xml");
		String msg = ctx.getMessage("k1", arg, defaultLocale);
 
		System.out.println(msg);
	}
}

5、默认时，显示为

country=CN
language=zh
欢迎你，悟空

当为美国US时，显示为

country=US
language=en
welcome： 悟空

资源访问

很多时候应用程序都需要存取资源。Spring提供了对资源文件的存取。ApplicationContext继承了ReourceLoader接口，开发人员可以使用getResource()方法并指定资源文件的URL来存取。

ApplicationContext对资源文件的读取有如下3种方式：

1.虚拟路径来存取

如果资源文件位于CLASSPATH下:可以通过这种方式来获取，代码如下

Resource resource=ctx.getResource("classpath:message.properties");

这里要说明的是"claspath:"是 spring约定的URL虚拟路径。

2.绝对路径来存取

指定标准的URL，例如“file:”或“”，代码如下

Resource source=ctx.getResource("file:D:/eclipse/workspace/Spring/src/main/resources/message.properties");

3.相对路径来存取

Resource source = actx.getResource("WEB-INF/message.properties");

当通过ApplicationContext取得一个Resource后，开发人员可以使用：

getFile() 来存取资源文件内容
exists()来检查资源文件是否存在
isOpen()检查资源文件是否被打开
getURL()返回资源文件的URL

完整test文件：

package com.yj.spring;
import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.Resource;
public class PropTest {
	@Test
	public void ClassPathTest() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("Beans.xml");
		Resource resource=ctx.getResource("classpath:message.properties");
		File file=resource.getFile();
		Properties prop=fileToProp(file);
		System.out.println("通过classptah路径获取:"+prop.getProperty("name"));
	}
	@Test
	public void RealPathTest() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("Beans.xml");
		Resource resource=ctx.getResource("file:D:/eclipse/workspace/Spring/src/main/resources/message.properties");
		File file=resource.getFile();
		Properties prop=fileToProp(file);
		System.out.println("通过实际路径获取:"+prop.getProperty("name"));
	}
	@Test
	public void virtualPathTest() throws Exception {
		ApplicationContext ctx = new FileSystemXmlApplicationContext("D:/eclipse/workspace/Spring/src/main/resources/Beans.xml");
		Resource resource=ctx.getResource("WEB-INF/message.properties");
		File file=resource.getFile();
		Properties prop=fileToProp(file);
		System.out.println("通过虚拟路径获取:"+prop.getProperty("name"));
	}
	private Properties fileToProp(File file) throws Exception{
		Properties prop = new Properties();
		prop.load(new FileInputStream(file));
		return prop;
	}
}

3.事件传递

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

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

ApplicationEvent：容器事件，必须由ApplicationContext发布
ApplicationListener：监听器，可由容器中的任何监听器Bean担任

实际上，Spring的事件机制与所有时间机制都基本相似，它们都需要事件源、事件和事件监听器组成。只是此处的事件源是ApplicationContext，且事件必须由Java程序显式触发。

下面的程序将演示Spring容器的事件机制。

Demo

1.项目整体结构

2.EmailController

package com.yj.event.controller;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.yj.event.email.EmailEvent;
import com.yj.event.email.EmailService;
 
@RestController
public class EmailController {
	@Autowired
	private EmailService emailService;
 
	@RequestMapping("/sendEmail")
	public void sendEmail() {
		EmailEvent emailEvent = new EmailEvent("source");
		emailEvent.setAddress("my address");
		emailEvent.setText("hello world");
		emailService.sendEmail(emailEvent);
	}
}

3.EmailEvent

程序先定义了一个EmailEvent类，其对象就是一个Spring容器事件。该类继承了ApplicationEvent类，除此之外，它就是一个普通的Java类。代码如下：

package com.yj.event.email;
 
import org.springframework.context.ApplicationEvent;
 
public class EmailEvent extends ApplicationEvent {
 
	private static final long serialVersionUID = 8890656093518139995L;
	private String address;
	private String text;
 
	public EmailEvent(Object source) {
		super(source);
	}
 
	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;
	}
}

4.EmailListener

两种实现方式，

@EventListener注解
一种实现ApplicationListener接口，重写onApplicationEvent方法

基于注解的方式

package com.yj.event.email;
 
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
 
@Component
public class EmailAnnoListener {
 
    @EventListener
    //@Async
    public void EmailEventListener(EmailEvent event) {
        try {
			System.out.println("开始休眠...");
			Thread.sleep(5000L);
			System.out.println("休眠结束...");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("EmailEventListener:"+event.getClass());
		System.out.println("注解监听到发送邮件的事件");
		System.out.println("注解需要发送的邮件地址: " + event.getAddress());
		System.out.println("注解邮件正文: " + event.getText());
    }
}

实现接口的方式

package com.yj.event.email;
 
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
 
 
//@Component
//@Async
public class EmailListener implements ApplicationListener<ApplicationEvent> {
 
	@Override
	public void onApplicationEvent(ApplicationEvent event) {
		System.out.println("EmailListener:" + event.getClass());
		if (event instanceof EmailEvent) {
			EmailEvent emailEvent = (EmailEvent) event;
			System.out.println("监听到发送邮件的事件");
			System.out.println("需要发送的邮件地址: " + emailEvent.getAddress());
			System.out.println("邮件正文: " + emailEvent.getText());
			try {
				Thread.sleep(5000L);
				System.out.println("休眠...");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

EmailEventListener方法或者onApplicationEvent方法，可以传入ApplicationEvent参数，监听所有的事件，本例只传入EmailEvent参数，只监听EmailEvent事件。然后将监听器配置在Spring的容器中。需注意的是，此时事件的发布，与事件的监听处理，默认是同步阻塞的，下文会开启异步的方式

5.EmailService

当系统创建Spring容器、加载Spring容器时会自动触发容器事件，容器事件监听器可以监听到这些事件。除此之外，程序也可以调用ApplicationContext的publishEvent()方法来主动触发一个容器事件

package com.yj.event.email;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
import com.yj.event.util.ApplicationContextUtil;
@Component
public class EmailService {
	public void sendEmail(EmailEvent event){
		ApplicationContext ctx=ApplicationContextUtil.getApplicationContext();
		ctx.publishEvent(event);
	}
}

6.ApplicationContextUtil

如果Bean想发布事件，则Bean必须获得其容器的引用。如果程序中没有直接获取容器的引用，则应该让Bean实现ApplicationContextAware或者BeanFactoryAware接口，从而可以获得容器的引用

package com.yj.event.util;
 
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
 
@Component
public class ApplicationContextUtil implements ApplicationContextAware {
 
    private static ApplicationContext applicationContext;
 
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }
 
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (ApplicationContextUtil.applicationContext == null) {
        	ApplicationContextUtil.applicationContext = applicationContext;
        }
    }
}

7.pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
 
	<groupId>com.yj</groupId>
	<artifactId>Event</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
 
	<name>Event</name>
	<url>http://maven.apache.org</url>
 
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.2.RELEASE</version>
		<relativePath />
	</parent>
 
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>
 
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	</dependencies>
</project>

8.app

package com.yj.event;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
//@EnableAsync
public class App {
	public static void main(String[] args) {
		SpringApplication.run(App.class, args);
	}
}

验证

访问路径

//127.0.0.1:8080/sendEmail

默认同步的情况下，显示结果

开始休眠...
休眠结束...
EmailEventListener:class com.yj.event.email.EmailEvent
注解监听到发送邮件的事件
注解需要发送的邮件地址: my address
注解邮件正文: hello world
结束

开启异步的情况（app.java类添加@EnableAsync注解，EmailAnnoListener类的EmailEventListener方法上添加@Async注解），有点MQ的效果，只是只能在一个ApplicationContext范围内才能捕获到事件的发布，才能起作用。

显示结果

结束
开始休眠...
休眠结束...
EmailEventListener:class com.yj.event.email.EmailEvent
注解监听到发送邮件的事件
注解需要发送的邮件地址: my address
注解邮件正文: hello world

Spring提供如下几个内置事件：

ContextRefreshedEvent：ApplicationContext容器初始化或刷新时触发该事件。此处的初始化是指：所有的Bean被成功装载，后处理Bean被检测并激活，所有Singleton Bean 被预实例化，ApplicationContext容器已就绪可用
ContextStartedEvent：当使用ConfigurableApplicationContext(ApplicationContext的子接口）接口的start()方法启动ApplicationContext容器时触发该事件。容器管理声明周期的Bean实例将获得一个指定的启动信号，这在经常需要停止后重新启动的场合比较常见
ContextClosedEvent：当使用ConfigurableApplicationContext接口的close()方法关闭ApplicationContext时触发该事件
ContextStoppedEvent：当使用ConfigurableApplicationContext接口的stop()方法使ApplicationContext容器停止时触发该事件。此处的停止，意味着容器管理生命周期的Bean实例将获得一个指定的停止信号，被停止的Spring容器可再次调用start()方法重新启动
RequestHandledEvent：Web相关事件，只能应用于使用DispatcherServlet的Web应用。在使用Spring作为前端的MVC控制器时，当Spring处理用户请求结束后，系统会自动触发该事件。

到此这篇关于Spring中ApplicationContext的拓展功能详解的文章就介绍到这了,更多相关ApplicationContext的拓展功能内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！