Spring中的Bean配置（一）

Spring中的bean配置

1.IOC和DI

1.IOC（Inversion of Control）：其思想是反转资源获取的方向，传统的资源查找方式要求组件向容器发起请求查找资源，
作为回应，容器适时的返回资源，而应用了IOC之后，则是容器主动的将资源推送给它所管理的组件，
组件所要做的仅是选择一种合适的方式来接受资源。这种行为也被成为查找的被动形式

2.DI（Dependency Injection）- IOC的另一种表述方式，即组件以一些预先定义好的方式（例如：setter方法）
接受来自如容器的资源注入，相对于IOC而言，这种表述更直接

eg

//容器
public void Test(){
	A a = getA();
	B b = getB();
	b.setA(a);
}
class A{}
class B(
	private A a;
	public void setA(A a){
		this.a=a;
	}
)
//IOC容器
public void IOCTest(){
	B b = getB();//可以自动调用
}//从容器中获取B对象，并使B对象的a属性被赋值为容器中A对象引用

2.在Spring的IOC容器里配置Bean

1.在xml文件中通过bean节点来配置bean

<bean name="helloWord" class="org.spring.beans.HelloWord">
	<property name="name" value="tom"></property>
</bean>

2.id：Bean的名称

	1.在IOC容器中必须是唯一的
	2.若id没有指定，Spring自动将权限定性类名作为Bean的名字
	3.id可以指定多个名字，名字之间可用逗号，分号，或空格分隔

3.Spring容器

1.在SpringIOC容器读取Bean配置创建Bean实例之前，必须对它进行实例化，只有在容器实例化后，才可以从IOC容器里获取Bean实例
2.Spring提供了两种类型的IOC容器实现
	1.BeanFactory：IOC容器的基本实现
	2.ApplicationContext：提供了更多高级的特性，是BeanFactory的子接口
	3.BeanFactory是Spring框架的基础设施，面向Spring本身；ApplicationContext面向使用Spring框架的开发者，
		几乎所有的应用场合都直接使用ApplicationContext而非底层的BeanFactory
	4.无论何种方式，配置文件是相同的

4.ApplicationContext

1.主要实现类
	1.ClassPathXMLApplicationContext：从类路径下加载配置文件
	2.FileSystemXMLApplicationContext：从文件系统中加载配置文件
2.ConfigurableApplicationContext扩展于ApplicationContext，新增加两个主要方法：refresh（）和close（），
	让ApplicationContext具有启动，刷新和关闭上下文的能力
3.ApplicationContext在初始化上下文时就实例化所有单例的Bean
4.WebApplicationContext是专门为WEB应用而准备的，它允许从相对于WEB根目录的路径中完成初始化工作

从IOC容器中获取Bean

调用ApplicationContext的getBean()方法

5.依赖注入方式

Spring支持3种依赖注入的方式
	1.属性注入
	2.构造器注入
	3.工厂方法注入（不推荐）

5.1.属性注入

1.属性通过注入即通过setter方法注入Bean的属性值或依赖对象
2.属性注入使用<property>元素，使用name属性指定Bean的属性名称，value属性或<value>子节点指定属性值
3.属性注入是实际应用中最常用的注入方式
<bean name="helloWord" class="org.spring.beans.HelloWord">
	<property name="name" value="tom"></property>
</bean>

5.2.构造器注入

1.通过构造方法注入Bean的属性值或以来的对象，他保证了Bean实例在实例化之后就可以使用。
2.构造器注入在<constructor-arg>元素里声明属性
3.按索引匹配入参index，按类型匹配入参Type

eg
1.新建Car类

public class Car {
	private String brand;
	private String corp;
	private double price;
	private int maxSpeed;
	
	public Car(String brand, String corp, double price) {
		super();
		this.brand = brand;
		this.corp = corp;
		this.price = price;
	}

	public Car(String brand, String corp, int maxSpeed) {
		super();
		this.brand = brand;
		this.corp = corp;
		this.maxSpeed = maxSpeed;
	}

	public Car() {
		super();
	}

	@Override
	public String toString() {
		return "Car [brand=" + brand + ", corp=" + corp + ", price=" + price + ", maxSpeed=" + maxSpeed + "]";
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public String getCorp() {
		return corp;
	}

	public void setCorp(String corp) {
		this.corp = corp;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	public int getMaxSpeed() {
		return maxSpeed;
	}

	public void setMaxSpeed(int maxSpeed) {
		this.maxSpeed = maxSpeed;
	}
}

2.在ApplicationContext.xml配置Bean

<bean id="car" class="org.spring.beans.Car">
	<constructor-arg value="audi"></constructor-arg>
	<constructor-arg value="shanghai"></constructor-arg>
	<constructor-arg value="200" type="int"></constructor-arg>
</bean>
<bean id="car2" class="org.spring.beans.Car">
	<constructor-arg value="bmw"></constructor-arg>
	<constructor-arg value="shanghai"></constructor-arg>
	<constructor-arg value="300000" type="double"></constructor-arg>
</bean>

3.测试类

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//通过Spring
		//创建Spring容器对象
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		Car car = (Car) ctx.getBean("car");
		System.out.println(car);
		Car car2 = (Car) ctx.getBean("car2");
		System.out.println(car2);
	}
}

5.2.2.字面值

1.字面值：可以字符串表示的值。可以通过<value>元素标签或value属性进行注入
2.基本数据类型及其封装类，String等类型都可以采取字面值注入的方式
3.若字面值中包含特殊字符，可以使用<![CDATA[]]>把字面值包裹起来

eg

<bean id="car2" class="org.spring.beans.Car">
	<constructor-arg value="bmw"></constructor-arg>
	<constructor-arg type="java.lang.String">
		<value><![CDATA[<tianjin>]]></value>
	</constructor-arg>
	<constructor-arg value="300000" type="double"></constructor-arg>
</bean>

5.2.3.引用其他Bean

1.组成应用程序的Bean经常需要相互协作以完成应用程序的功能，要使Bean能够相互访问，就必须在Bean配置文件中指定对Bean的引用
2.在Bean的配置文件中，可以通过<ref>元素或ref属性为Bean的属性或构造器参数指定对Bean的引用
3.也可以在属性或构造器里包含Bean的声明，这样的Bean称为内部Bean

eg
1.新建Person类

public class Person {
	
	private String name;
	private int age;
	private Car car;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Car getCar() {
		return car;
	}
	public void setCar(Car car) {
		this.car = car;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
	}	
}

2.配置ApplicationContext.xml文件（一个人有一辆车）

<bean id="car2" class="org.spring.beans.Car">
	<constructor-arg value="bmw"></constructor-arg>
	<constructor-arg type="java.lang.String">
		<value><![CDATA[<tianjin>]]></value>
	</constructor-arg>
	<constructor-arg value="300000" type="double"></constructor-arg>
</bean>

<bean id="person" class="org.spring.beans.Person">
	<property name="name" value="tom"></property>
	<property name="age" value="23"></property>
	<!-- <property name="car" ref="car2"></property> -->
	<property name="car">
		<ref bean="car2">
	</property>
</bean>

2.1.测试类

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//通过Spring
		//创建Spring容器对象
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		Person person = (Person) ctx.getBean("person");
		System.out.println(person);

	}
}

5.2.4.内部Bean

1.当Bean实例仅仅给一个特定的属性使用时，可以将其声明为内部Bean。内部Bean声明直接包含在<property>或<constructor-arg>元素里，不需要设置任何id或name属性
2.内部Bean不能使用在任何其他地方

eg
1.配置ApplicationContext.xml

<bean id="person2" class="org.spring.beans.Person">
	<property name="name" value="tom1"></property>
	<property name="age" value="23"></property>
	<property name="car" >
		<bean class="org.spring.beans.Car">
			<constructor-arg value="audi"></constructor-arg>
			<constructor-arg  value="tianjin"></constructor-arg>
			<constructor-arg value="300000" type="double"></constructor-arg>
		</bean>
	</property>
</bean>

2.测试方法

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//通过Spring
		//创建Spring容器对象
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		Person person = (Person) ctx.getBean("person2");
		System.out.println(person);

	}
}

5.2.5.注入参数详解：null值和级联属性

可以使用专门的<null/>元素标签为Bean的字符串或其他对象类型的属性注入null值

eg
null元素
1.配置ApplicationContext.xml

<bean id="person3" class="org.spring.beans.Person">
	<property name="name" value="tom"></property>
	<property name="age" value="23"></property>
	<property name="car" >
		<null></null>
	</property>
</bean>

2.测试类

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//通过Spring
		//创建Spring容器对象
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		Person person = (Person) ctx.getBean("person3");
		System.out.println(person);

	}
}

级联属性（通过person端给car注入属性）
1.配置ApplicationContext.xml

<bean id="car" class="org.spring.beans.Car">
	<constructor-arg value="audi"></constructor-arg>
	<constructor-arg value="shanghai"></constructor-arg>
	<constructor-arg value="200" type="int"></constructor-arg>
</bean>

<bean id="person4" class="org.spring.beans.Person">
	<property name="name" value="tom"></property>
	<property name="age" value="23"></property>
	<property name="car" ref="car2"></property>
	<property name="car.maxSpeed" value="230"></property>
</bean>

2.测试

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//通过Spring
		//创建Spring容器对象
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		Person person = (Person) ctx.getBean("person4");
		System.out.println(person);

	}
}

5.2.6.list集合属性

一个人多有辆车
eg
1.新建Person2类

public class Person2 {
	
	private String name;
	private int age;
	private List<Car> car;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public List<Car> getCar() {
		return car;
	}
	public void setCar(List<Car> car) {
		this.car = car;
	}
	@Override
	public String toString() {
		return "Person2 [name=" + name + ", age=" + age + ", car=" + car + "]";
	}	
}

2.配置ApplicationContext.xml

<bean id="car" class="org.spring.beans.Car">
	<constructor-arg value="audi"></constructor-arg>
	<constructor-arg value="shanghai"></constructor-arg>
	<constructor-arg value="200" type="int"></constructor-arg>
</bean>

<bean id="car2" class="org.spring.beans.Car">
	<constructor-arg value="bmw"></constructor-arg>
	<constructor-arg type="java.lang.String">
		<value><![CDATA[<tianjin>]]></value>
	</constructor-arg>
	<constructor-arg value="300000" type="double"></constructor-arg>
</bean>

<bean id="person5" class="org.spring.beans.Person2">
	<property name="name" value="jack"></property>
	<property name="age" value="23"></property>
	<property name="car">
		<list>
			<ref bean="car"/>
			<ref bean="car2"/>
		</list>
	</property>
</bean>

3.测试类

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//通过Spring
		//创建Spring容器对象
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		Person2 person = (Person2) ctx.getBean("person5");
		System.out.println(person);

	}
}

5.2.7.map属性

eg
1.新建NewPerson类

public class NewPerson {

	private String name;
	private int age;
	private Map<String,Car> cars;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Map<String, Car> getCars() {
		return cars;
	}
	public void setCars(Map<String, Car> cars) {
		this.cars = cars;
	}
	@Override
	public String toString() {
		return "NewPerson [name=" + name + ", age=" + age + ", cars=" + cars + "]";
	}
}

2.配置ApplicationContext.xml

<bean id="car" class="org.spring.beans.Car">
	<constructor-arg value="audi"></constructor-arg>
	<constructor-arg value="shanghai"></constructor-arg>
	<constructor-arg value="200" type="int"></constructor-arg>
</bean>

<bean id="car2" class="org.spring.beans.Car">
	<constructor-arg value="bmw"></constructor-arg>
	<constructor-arg type="java.lang.String">
		<value><![CDATA[<tianjin>]]></value>
	</constructor-arg>
	<constructor-arg value="300000" type="double"></constructor-arg>
</bean>

<bean id="newPerson" class="org.spring.beans.NewPerson">
	<property name="name" value="jack"></property>
	<property name="age" value="23"></property>
	<property name="cars">
		<map>
			<entry key="AA" value-ref="car"></entry>
			<entry key="BB" value-ref="car2"></entry>
		</map>
	</property>
</bean>

3.测试类

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//通过Spring
		//创建Spring容器对象
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		NewPerson newperson = (NewPerson) ctx.getBean("newPerson");
		System.out.println(newperson);


	}
}

5.2.8.properties属性配置（数据源的连接）

eg
1.新建DataSource类

public class DataSourse {

	private Properties properties;

	public Properties getProperties() {
		return properties;
	}

	public void setProperties(Properties properties) {
		this.properties = properties;
	}

	@Override
	public String toString() {
		return "DataSourse [properties=" + properties + "]";
	}	
}

2.配置ApplicationContext.xml文件

<bean id="dataSourse" class="org.spring.beans.DataSourse">
	<property name="properties" >
		<props>
			<prop key="user">root</prop>
			<prop key="password">password</prop>
			<prop key="jdbcurl">jdbcurl</prop>
			<prop key="driverclass">driverclass</prop>
		</props>
	</property>
</bean>

3.测试类

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//通过Spring
		//创建Spring容器对象
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		DataSourse dataSourse = (DataSourse) ctx.getBean("dataSourse");
		System.out.println(dataSourse);
	}
}

5.2.9.使用utility scheme定义集合（集合分离）

1.使用基本的集合标签定义集合时，不能将集合作为独立的Bean定义，导致其他Bean无法引用该集合，所以无法在不同的Bean之间共享集合
2.可以使用util scheme里的集合标签定义独立的集合Bean，需要注意的是，必须在<beans>根元素里添加util scheme定义

eg
1.配置ApplicationContext.xml点击Namespace里勾选util标签

<bean id="car" class="org.spring.beans.Car">
	<constructor-arg value="audi"></constructor-arg>
	<constructor-arg value="shanghai"></constructor-arg>
	<constructor-arg value="200" type="int"></constructor-arg>
</bean>

<bean id="car2" class="org.spring.beans.Car">
	<constructor-arg value="bmw"></constructor-arg>
	<constructor-arg type="java.lang.String">
		<value><![CDATA[<tianjin>]]></value>
	</constructor-arg>
	<constructor-arg value="300000" type="double"></constructor-arg>
</bean>

<util:list id="cars">
	<ref bean="car"/>
	<ref bean="car2"/>
</util:list>

<bean id="person6" class="org.spring.beans.Person2">
	<property name="name" value="jack"></property>
	<property name="age" value="23"></property>
	<property name="car" ref="cars"></property>
</bean>

2.测试类

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//通过Spring
		//创建Spring容器对象
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		Person2 person6 = (Person2) ctx.getBean("person6");
		System.out.println(person6);
	}
}

5.2.10 使用P命名空间

1.为了简化XML文件的配置，越来越多的XML文件采用属性而非子元素配置信息
2.Spring从2.5版本开始引入了一个新的p命名空间，可以通过<bean>元素属性的方式配置Bean的属性
3.使用p命名空间后，基于XML的配置方式将进一步简化

eg
1.配置ApplicationContext.xml点击Namespace里勾选p标签

<bean id="car" class="org.spring.beans.Car">
	<constructor-arg value="audi"></constructor-arg>
	<constructor-arg value="shanghai"></constructor-arg>
	<constructor-arg value="200" type="int"></constructor-arg>
</bean>

<bean id="car2" class="org.spring.beans.Car">
	<constructor-arg value="bmw"></constructor-arg>
	<constructor-arg type="java.lang.String">
		<value><![CDATA[<tianjin>]]></value>
	</constructor-arg>
	<constructor-arg value="300000" type="double"></constructor-arg>
</bean>

<util:list id="cars">
	<ref bean="car"/>
	<ref bean="car2"/>
</util:list>

<bean id="person7" class="org.spring.beans.Person2" p:age="30" p:name="zhangsan" p:car-ref="cars">
	
</bean>

2.测试类

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//通过Spring
		//创建Spring容器对象
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		Person2 person7 = (Person2) ctx.getBean("person7");
		System.out.println(person7);

	}
}