Spring中Bean的配置（二）

1.xml配置里的bean自动装配

1.SpringIOC容器可以自动装配Bean，需要做的仅仅是在<bean>的autowire属性里指定自动装配的模式
2.byType（根据类型自动装配）：若IOC容器中有多个与目标Bean类型一致的Bean在这种情况下，
	Spring将无法判定哪个Bean最合适该属性，所以不能执行自动装配
3.byName（根据名称自动装配）必须将目标Bean的名称和属性名设置的完全相同
4.constructor（通过构造器自动装配）：当Bean中存在多个构造器时，此种自动装配方式将会很复杂（不推荐使用）

eg
1.创建Person，Car，Address类

public class Person {
	
	private String name;
	
	private Adress adress;
	
	private Car car;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Adress getAdress() {
		return adress;
	}

	public void setAdress(Adress adress) {
		this.adress = adress;
	}

	public Car getCar() {
		return car;
	}

	public void setCar(Car car) {
		this.car = car;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", adress=" + adress + ", car=" + car + "]";
	}	
}

public class Car {
	
	private String brand;
	private double price;
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	@Override
	public String toString() {
		return "Car [brand=" + brand + ", price=" + price + "]";
	}
}

public class Adress {
	private String city;
	private String street;
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public String getStreet() {
		return street;
	}
	public void setStreet(String street) {
		this.street = street;
	}
	@Override
	public String toString() {
		return "Adress [city=" + city + ", street=" + street + "]";
	}
}

2.配置autowiredBeaans.xml

<bean id="adress" class="org.spring.autowire.beans.Adress" p:city="AA" p:street="BB"></bean>
<bean id="car" class="org.spring.autowire.beans.Car" p:brand="CC" p:price="30000"></bean>
<!-- 	<bean id="car2" class="org.spring.autowire.beans.Car" p:brand="CC1" p:price="30000"></bean> -->
<bean id="person" class="org.spring.autowire.beans.Person" p:name="tom" autowire="byName"></bean>
<!-- 	<bean id="person" class="org.spring.autowire.beans.Person" p:name="tom" autowire="byType"></bean> -->
<!--  如果使用byType  以上俩个car目标Bean类型一致 在这种情况下，Spring将无法判定哪个Bean最合适该属性，所以不能执行自动装配 -->

3.测试类

public class Test2 {

	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		ApplicationContext ctx = new ClassPathXmlApplicationContext("autowiredBeaans.xml");
		
		Person person = (Person) ctx.getBean("person");
		System.out.println(person);
	}
}

2.Bean的作用域

1.在Spring中，可以在<bean>元素的scope属性里设置Bean的作用域
2.默认情况下，Spring只为每个在IOC容器里声明Bean创建唯一一个实例，整个容器范围内都能共享该实例，
所有后续的getBean()调用和Bean引用都将返回这个唯一的Bean实例，该作用域被称为singleton，它是所有Bean的默认作用域
	1.scope="singleton" 在SpringIOC容器中仅存在一个Bean实例，Bean以单实例的方式存在
	2.scope="prototype" 每次调用getBean()时都会返回一个新的实例
	3.scope="request" 每次HTTP请求都会创建一个新的Bean，该作用域仅适用于WebApplicationContext环境
	4.scope="session" 同一个HTTP Session共享一个Bean，不同的HTTP Session使用不同的Bean。该作用域仅适用于WebApplicationContext环境

eg
1.

	Car car = (Car) ctx.getBean("car");
	Car car2 = (Car) ctx.getBean("car");
	System.out.println(car == car2);//true

2.autowireBeans.xml配置

<bean id="car" class="org.spring.autowire.beans.Car" p:brand="CC" p:price="30000" scope="prototype"></bean>

Car car = (Car) ctx.getBean("car");
Car car2 = (Car) ctx.getBean("car");
System.out.println(car == car2);//false scope="prototype"指向不同的空间

3.使用外部属性文件

1.在配置文件里配置Bean时，有时需要在Bean的配置里混入系统部署的细节信息（例如：文件路径，书记员配置信息等）而这些部署细节实际上需要和Bean配置分离
2.Spring提供了一个PropertyPlaceholderConfigurer的BeanFactory后置处理器，这个处理器允许用户将Bean配置的部分内容移到属性文件中。可以在Bean配置文件里使用形式为${var}的变量，PropertyPlaceholderConfigurer从属性文件里加载属性，并使用这些属性来替换变量。
3.Spring还允许在属性文件中使用${propName}，以实现属性之间的相互引用

Spring2.5之后：通过<context:property-placeholder>元素简化
	1.<beans>中添加context Schema定义
	2.在配置文件中加入如下配置
	<context:property-placeholder location="classpath:db.properties"/>

eg
1.新建db.properties

jdbc.user=root
jdbc.password=zzj6660534
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///hpspring

2.autowireBeans.xml配置

<context:property-placeholder location="classpath:db.properties"/>

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="user" value="${user}"></property>
	<property name="password" value="${password}"></property>
	<property name="driverClass" value="${driverClass}"></property>
	<property name="jdbcUrl" value="${jdbcUrl}"></property>
</bean>

3.测试类

public static void main(String[] args) throws Exception{
	// TODO Auto-generated method stub
	ApplicationContext ctx = new ClassPathXmlApplicationContext("autowiredBeaans.xml");
	
	DataSource ds = (DataSource) ctx.getBean("dataSource");
	System.out.println(ds.getConnection());
	
}

4.容器中Bean的生命周期的方法

1.SpringIOC容器可以管理Bean的生命周期，Spring允许在Bean生命周期的特定点执行制定的任务
2.SpringIOC容器对Bean的生命周期进行管理的过程
	1.通过构造器或工厂方法创建Bean实例
	2.为Bean的属性设置值和对其他Bean的引用
	3.调用Bean的初始化方法
	4.Bean可以使用了
	5.当容器关闭时，调用Bean的销毁方法
3.在Bean的声明里设置init-method和destroy-method属性，为Bean指定初始化和销毁方法

eg
1.新建Car类

public class Car {
	private String brand;

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
		System.out.println("Car's setBrand ……"+brand);
	}

	public Car() {
		super();
		System.out.println("Car's Constuctor ……");
	}
	
	public Car(String brand) {
		super();
		this.brand = brand;
	}

	public void init() {
		System.out.println("init……");
	}
	
	public void destroy() {
		System.out.println("destroy……");
	}
}

2.autowireBeans.xml配置

<bean id="car2" class="org.spring.init.beans.Car" p:brand="init" init-method="init" destroy-method="destroy"></bean>

3.测试类

public static void main(String[] args) {
	// TODO Auto-generated method stub
	ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("autowiredBeaans.xml");

	Car car2 = (Car) ctx.getBean("car2");
	
	System.out.println(car2);
	
	//System.out.println();
	
	ctx.close();
	
}

5.创建bean的后置处理器

1.Bean后置处理器允许在调用初始化方法前后对Bean进行额外的处理
2.Bean后置处理器对IOC容器里的所有Bean实例逐一处理，而非单一实例，其典型应用是：检查Bean属性的正确性或根据特定的标准改变Bean的属性
3.对Bean后置处理器而言，需要实现接口，在初始化方法被调用前后，Spring将把每个Bean实例分别传递给上述接口的以下两个方法
接口：BeanPostProcessor
方法：postProcessAfterInitialization/postProcessBeforeInitialization

eg
1.新建MyBeanPostProcessor.java

public class MyBeanPostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("---postProcessAfterInitialization:"+bean+"_"+beanName);
		return bean;
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("---postProcessBeforeInitialization:"+bean+"_"+beanName);
	}
}

2.autowireBeans.xml配置

<bean class="org.spring.init.beans.MyBeanPostProcessor"></bean>

3.测试类；

public static void main(String[] args) {
	// TODO Auto-generated method stub
	ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("autowiredBeaans.xml");

	Car car2 = (Car) ctx.getBean("car2");
	
	System.out.println(car2.getBrand());
	
	//System.out.println();
	
	ctx.close();
}

可在后置处理器修改值

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
	// TODO Auto-generated method stub
	System.out.println("---postProcessBeforeInitialization:"+bean+"_"+beanName);
	Car car = new Car();
	car.setBrand("bwm");
	return car;
}

6.通过调用静态工厂方法创建Bean

1.调用静态工厂方法创建Bean是将对象创建的过程封装到静态方法中，当客户端需要对象时，只需要简单的调用静态方法，而不用关心创建对象的细节
2.要声明通过静态方法创建的Bean，需要在Bean的class属性里指定拥有该工厂的方法的类，同时在Factory=method属性里指定工厂方法的名称，最后使用<constructor-arg>元素为该方法传递方法参数

eg
1.新建InstanceCarFactory.java

public class InstanceCarFactory {
	private Map<String, Car> cars;
	
	public InstanceCarFactory() {
		cars = new HashMap<String, Car>();
		
		cars.put("audi", new Car("audi"));
		cars.put("ford", new Car("ford"));
	}

	public Car getCars(String brand) {
		return cars.get(brand);
	}	
}

2.新建factoryBeans.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.xsd">

	<bean id="carFactory" class="org.spring.beans.factory.InstanceCarFactory"></bean>
	
	<bean id="car2" factory-bean="carFactory" factory-method="getCars">
		<constructor-arg value="ford"></constructor-arg>
	</bean>
		
	
</beans>

3.测试类

public class Test4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ApplicationContext ctx = new ClassPathXmlApplicationContext("factoryBeans.xml");
		
		Car car = (Car) ctx.getBean("car2");
		
		System.out.println(car.getBrand());
	}

}

7.通过调用实例方法创建Bean

1.实例工厂方法：将对象的创建过程封装到另一个对象实例的方法里，当客户端需要请求对象时，
只需要简单的调用该实例方法而不需要关心对象的创建细节
2.要声明通过实例工厂方法创建的Bean
	1.在bean的factory-bean属性里指定拥有该工厂方法的Bean
	2.在factory-method属性里指定该工厂方法的名称
	3.使用constructor-arg元素为工厂方法传递方法参数

实现factoryBean接口在SpringIOC容器中配置Bean

1.Spring中有两种类型的Bean，一种是普通的Bean，另一种是工厂Bean，即FactoryBean
2.工厂Bean跟普通Bean不同，其返回的对象不是指定类的一个实例，其返回的是该工厂Bean的getObject方法所返回的对象