spring 第1天 IOC,DI,国际化,容器事件

1.构造注入(就是使用 构造方法)
2,设值注入(就是使用setXX()方法)

package cn.sh.springmvc.service.user;

import cn.sh.springmvc.dao.UserDAO;


public class UserService {
	private String name;
	private int age;
	
	private UserDAO userdao;
	
	public void info(){
		System.out.println("名称为："+name+"年龄："+age);
	}
	//设值注入
	public void setName(String name) {
		this.name = name;
	}
	public UserService() {
		System.out.println("调用servie:service初始化");
	}

	//采用构造注入
	public UserService(int age) {
		this.age = age;
	}
	public UserService(UserDAO userdao) {
		super();
		this.userdao = userdao;
	}
	public UserDAO getUserdao() {
		return userdao;
	}
	public void setUserdao(UserDAO userdao) {
		this.userdao = userdao;
	}
}

<bean id="userService" class="cn.sh.springmvc.service.user.UserService" >
                <!--构造注入-->
		<constructor-arg name="age" value="18" type="int"/>
                <!--设值注入-->
		<property name="name" value="wawa"/>
	</bean>

Spring 容器:最基本的接口就是BeanFactory,BeanFactory负责配置,创建,管理Bean,它有一个子接口ApplicationContext,被称为"上下文",spring 还负责管理Bean和Bean之间的关系

//BeanFactory接口包含如下几个基本方法
boolean containsBean(String name); //判断spring容器中是否保航id为name的bean实例
<T> T getBean(Class<T> requiredType);//获取Spring容器中属于requiredType类型的唯一实例.
Object getBean(String name); //返回容器中ID为name的Bean实例
<T> T getBean(String name,Class requiredType) ;//返回容器中ID为name,并且类型为requiredType的Bean.
Class<?> getType(String name);//返回容器中指定Bean的实例类型.

//BeanFactory 有一个常用的实现类:XmlBeanFactory
//BeanFactory 有一个子接口:ApplicationContext 该接口的实现类有:
//1:FileSystemXmlApplicationContent
//2:ClassPathXmlApplicationContext
//3:XmlWebApplicationContext  (web中常用)
//4:AnnotaionConfigXmlApplicationContext (web中常用)

//一般的java应用程序  非web 
InputStreamResource isr=new FileSystemResource("applicationContext.xml");
XmlBeanFactory factory=new XmlBeanFactory(isr);

//或者

ClassPathResource res=new ClassPathResource("appliactionContext.xml");
XmlBeanFactory factory=new XmlBeanFactory(res);


//如果有多个配置文件采用BeanFactory的子接口
ApplicationContext act=new ClassPathXmlApplicationContext(new String[]{"bean.xml","bean1.xml"});

//或者
ApplicationContext act=new FileSystemApplicationContext(new String[]{"bean.xml","bean1.xml"});

Spring 的配置文件

<!--采用 XML Schema 来定义配置文件-->
<?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:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans   
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd   
    http://www.springframework.org/schema/tx   
    http://www.springframework.org/schema/tx/spring-tx-3.2.xsd  
    http://www.springframework.org/schema/context  
    http://www.springframework.org/schema/context/spring-context-3.2.xsd  
    http://www.springframework.org/schema/mvc  
    http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd" 
    default-autowire-candidates="*abc" default-lazy-init="true">

...bean
</beans>

<!--采用DTD来定义配置文件 :-->
<!--如果用DTD方式：配置文件中就不能使用spring2.X Spring3.0新增的配置标签 
比如:2.x dependency-check 属性
3.0 JSP 标签,  Hibernate标签, Tiles 2.2 标签
-->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
  
...bean
</beans>

applicatoinContext:一般不会使用 BeanFactory的实例,而是使用 ApplicationContext,因为 它包含了BeanFactory的所有功能功能,而且还提供了额外的功能:

//1:ApplicatonContext 继承了MessageSource接口,因此提供了国际化支持
//2:提供了资源访问,比如URL和文件
//3:事件机制
//4:载入多个配置文件
//5:以声明的方式启动,并创建Spring容器

//当系统初始化ApplicaitonContext容器的时候,会初始化所有的singletion Bean.因此刚开始的时候可能需要消耗较大的系统开销.

ApplicationContext支持的国际化

<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
		<property name="basenames">
			<list>
				<value>message</value>
				<!-- 多个开头的资源文件.... -->
			</list>
		</property>
</bean>

<!--message_en_US.properties-->
hello=welcom,{0}
now=now is:{0}
<!--message_zh_CN.properties-->
hello=欢迎你,{0}
now=现在时间是:{0}

<!--native2ascii message.properties message_zh_CN.properties-->

@Test
	public void test1() {
		ApplicationContext act=new ClassPathXmlApplicationContext("classpath*:applicationContent.xml");
		
		String [] args={"读者"};
		Object [] args1={new Date()};
		String hello=act.getMessage("hello", args, Locale.getDefault());
		String now=act.getMessage("now", args1, Locale.getDefault());
		System.out.println(hello);
		System.out.println(now);
	}

//syso:
//欢迎你,读者
//现在时间是:14-8-4 下午10:14

ApplicationContext的事件机制 :采用的是观察者设计模式,通过ApplicationEvent和ApplicationListener,就可以对ApplicationContext的事件处理

//定义容器事件
package cn.sh.springmvc.applicationContext;

import org.springframework.context.ApplicationEvent;

/**
 * spring 的applicationEvent 事件机制 主要采用 观察者模式
 * 
 *  1、  ContextRefreshedEvent：ApplicationContext容器初始化或者刷新时触发该事件。
    2、  ContextStartedEvent：当使用ConfigurableApplicationContext接口的start()方法启动ApplicationContext容器时触发该事件。
    3、  ContextClosedEvent：当使用ConfigurableApplicationContext接口的close()方法关闭ApplicationContext容器时触发该事件。
    4、  ContextStopedEvent: 当使用ConfigurableApplicationContext接口的stop()方法停止ApplicationContext容器时触发该事件。
    5、 RequestHandledEvent:Web相关时间，只能应用与使用DispatcherServet 的Web应用，
    	在使用spring作为前端的MVC控制器是，当spring处理用户请求后，系统会自动触发 该事件
    
 *
 */
public class EmailEvent extends ApplicationEvent {

	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;
	}

	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;
	}	

}

//定义一个容器监听
package cn.sh.springmvc.applicationContext;

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 emevt=(EmailEvent)evt;
			System.out.println("需要发送邮件的接收地址："+emevt.getAddress());
			System.out.println("需要发送邮件的邮件正文："+emevt.getText());
		}else {
			System.out.println("容器本身的事件："+evt);
		}
	}
}

//在applicationContext.xml中加入一个监听bean
<bean class="cn.sh.springmvc.applicationContext.EmailNotifier"/>

//测试spring容器事件
	@Test
	public void test2() {
		ApplicationContext act=new ClassPathXmlApplicationContext("classpath*:applicationContent.xml");
		
		EmailEvent ele=new EmailEvent("hello","spring_test@163.com","this is a test");
		act.publishEvent(ele);//主动触发容器事件
	}

让Bean获取spring容器:只需要实现 ApplicationContextAware 接口就可以获取spring容器了

package cn.sh.springmvc.applicationContextAware;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * 让Bean获取Spring容器
 */
public class MyContent implements ApplicationContextAware,BeanNameAware,InitializingBean,DisposableBean{

	private ApplicationContext act;
	private String beanName;
	@Override
	public void setApplicationContext(ApplicationContext act)
			throws BeansException {
		System.out.println("ApplicationContextAware 接口的 获取容器对象方法");
		this.act=act;
	}

	public ApplicationContext getContext(){
		return act;
	}

	@Override
	public void destroy() throws Exception {
		System.out.println("DisposableBean 接口的方法:即将被销毁");
	}

	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("InitializingBean 接口的方法:Bean所有属性初始化完成后,执行的一个初始化方法");
	}

	@Override
	public void setBeanName(String name) {
		System.out.println("BeanNameAware接口,获取 Bean的name");
		beanName=name;
	}

	public String getBeanName() {
		return beanName;
	}
	
}

	<!--定义一个能够获取spring容器的bean  -->
	<bean id="myContent" name="CH,CN" class="cn.sh.springmvc.applicationContextAware.MyContent" lazy-init="true">
	</bean>
	<alias name="CH" alias="ZG"/>
	
	<alias name="chinese" alias="ZH"/>
	<!-- 别名之间还可以传承 -->
	<alias name="ZH" alias="HH"/>

//使用bean 获取 spring容器 ，一般不建议这样使用，除非有特别必要
	@Test
	public void test3() {
		ApplicationContext act=new ClassPathXmlApplicationContext("classpath*:applicationContent.xml");
		MyContent p=act.getBean("chinese",MyContent.class);
		System.out.println(p.getContext());
		System.out.println(act==p.getContext());
	}