Spring总结_04_容器和bean
2017-03-16 12:29
288 查看
一.概念理解
IoC容器负责容纳并管理bean，在Spring中，
Spring提供两种IoC容器的实现：
（1）BeanFactory ：org.springframework.beans.factory.BeanFactory 是Spring IoC容器的基本实现，是Spring IoC容器实际代表者
BeanFactory是Spring框架的基础设施，面向Spring本身
（2）ApplicationContext：提供了更多的高级特性，是BeanFactory的子类。
ApplicationContext面向开发者。几乎所有的场合都直接使用ApplicationContext而非底层的BeanFactory。
ApplicationContext 的主要实现类：
ClassPathXmlApplicationContext：从 类路径下加载配置文件
FileSystemXmlApplicationContext: 从文件系统中加载配置文件
ConfigurableApplicationContext 扩展于 ApplicationContext，新增加两个主要方法：refresh() 和 close()， 让 ApplicationContext 具有启动、刷新和关闭上下文的能力
2.bean
在Spring中，那些组成你应用程序的主体(backbone)及由Spring IoC容器所管理的对象，被称之为bean。 简单地讲，bean就是由Spring容器初始化、装配及管理的对象
bean的定义由
全限定类名： 这通常就是已定义bean的实际实现类。
bean行为的定义： 这些定义将决定bean在容器中的行为（作用域、生命周期回调等等）
对其他bean的引用： 这些引用bean也可以称之为协作bean（collaborators） 或依赖bean（dependencies）.
创建bean实例时的其他配置设置。比如使用bean来定义连接池，可以通过属性或者构 造参数指定连接数，以及连接池大小限制等。
上述内容直接被翻译为每个bean定义包含的一组properties。
二.bean的配置
1. 简单实例
java bean: HelloWorld.java
View Code
配置文件：applicationContext.xml
View Code
bean的实例化：Main.java
View Code
2. bean的依赖注入
Spring 支持 3 种依赖注入的方式：属性注入、构造器注入、工厂方法注入（很少使用，不推荐）
2.1 属性注入
属性注入即通过 setter 方法注入Bean 的属性值或依赖的对象
属性注入是实际应用中最常用的注入方式。
View Code
2.2 构造器注入
构造器注入即 通过配置构造器参数，来注入Bean 的属性值或依赖的对象，它保证了 Bean 实例在实例化后就可以使用。
Java bean： Car.java
View Code
配置文件： applicationContext.xml
View Code
bean的实例化：
View Code
3.注入参数详解
3.1 字面值
（1） 字面值：可用字符串表示的值，可以通过 <value> 元素标签或 value 属性进行注入。
（2）基本数据类型及其封装类、String 等类型都可以采取字面值注入的方式
（3） 若字面值中包含特殊字符，可以使用 <![CDATA[]]> 把字面值包裹起来。
View Code
3.2 引用其他bean
组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能. 要使 Bean 能够相互访问, 就必须在 Bean 配置文件中指定对 Bean 的引用
实体类：Car.java
View Code
Person.java
View Code
两种方式：
（1）使用property的 ref 属性 ： 在 Bean 的配置文件中, 可以通过 <ref> 元素或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用.
配置文件： applicationContext.xml
View Code
（2）内部bean ：在属性或构造器里包含 Bean 的声明, 这样的 Bean 称为内部 Bean
View Code
3.3 null值和级联属性
null
View Code
级联属性
View Code
3.4 集合属性
在 Spring中可以通过一组内置的 xml 标签(例如: <list>, <set> 或 <map>) 来配置集合属性.
（1）List属性配置： 配置 java.util.List 类型的属性, 需要指定 <list> 标签, 在标签里包含一些元素. 这些标签可以通过 <value> 指定简单的常量值,
通过 <ref> 指定对其他 Bean 的引用. 通过<bean> 指定内置 Bean 定义. 通过 <null/> 指定空元素. 甚至可以内嵌其他集合.
实体类：Car.java
View Code
Person.java
View Code
配置文件： applicationContext.xml
View Code
bean的实例化：Main.java
View Code
(2)数组的定义和 List 一样, 都使用 <list>
(3)配置 java.util.Set 需要使用 <set> 标签, 定义元素的方法与 List 一样.
(4)Map属性配置： Java.util.Map 通过 <map> 标签定义, <map> 标签里可以使用多个 <entry> 作为子标签. 每个条目包含一个键和一个值. 必须在 <key> 标签里定义键因为键和值的类型没有限制, 所以可以自由地为它们指定 <value>, <ref>, <bean> 或 <null> 元素.
可以将 Map 的键和值作为 <entry> 的属性定义: 简单常量使用 key 和 value 来定义; Bean 引用通过 key-ref 和 value-ref 属性定义；
使用 <props> 定义： Map的子类 java.util.Properties, 该标签使用多个 <prop> 作为子标签. 每个 <prop> 标签必须定义 key 属性.
实体类：Car.java
View Code
Person.java
View Code
DataSource.java
View Code
配置文件： applicationContext.xml
View Code
bean的实例化：Main.java
View Code
3.5 p命名空间
配置文件： applicationContext.xml
View Code
1.容器
IoC容器负责容纳并管理bean，在Spring中，
BeanFactory是IoC容器的核心接口。 它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。
Spring提供两种IoC容器的实现：
（1）BeanFactory ：org.springframework.beans.factory.BeanFactory 是Spring IoC容器的基本实现，是Spring IoC容器实际代表者
BeanFactory是Spring框架的基础设施，面向Spring本身
（2）ApplicationContext：提供了更多的高级特性，是BeanFactory的子类。
ApplicationContext面向开发者。几乎所有的场合都直接使用ApplicationContext而非底层的BeanFactory。
ApplicationContext 的主要实现类：
ClassPathXmlApplicationContext：从 类路径下加载配置文件
FileSystemXmlApplicationContext: 从文件系统中加载配置文件
ConfigurableApplicationContext 扩展于 ApplicationContext，新增加两个主要方法：refresh() 和 close()， 让 ApplicationContext 具有启动、刷新和关闭上下文的能力
2.bean
在Spring中，那些组成你应用程序的主体(backbone)及由Spring IoC容器所管理的对象，被称之为bean。 简单地讲，bean就是由Spring容器初始化、装配及管理的对象
bean的定义由
BeanDefinition对象来表示，该定义将包含以下信息：
全限定类名： 这通常就是已定义bean的实际实现类。
bean行为的定义： 这些定义将决定bean在容器中的行为（作用域、生命周期回调等等）
对其他bean的引用： 这些引用bean也可以称之为协作bean（collaborators） 或依赖bean（dependencies）.
创建bean实例时的其他配置设置。比如使用bean来定义连接池，可以通过属性或者构 造参数指定连接数，以及连接池大小限制等。
上述内容直接被翻译为每个bean定义包含的一组properties。
二.bean的配置
1. 简单实例
java bean: HelloWorld.java
package com.ray.spring;
public class HelloWorld {
private String name;
public void setName(String name){
this.name=name;
}
public void hello(){
System.out.println("hello:"+name);
}
}View Code
配置文件：applicationContext.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:util="http://www.springframework.org/schema/util" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"> <!-- 配置一个 bean class:bean的全类名，通过反射的方式在IoC容器中创建Bean.所以要求Bean中必须有无参构造器 id:标识容器中的bean,id唯一。若有多个id,则第一个是标识符，其他为别名。 --> <bean id="helloWorld" class="com.ray.spring.HelloWorld"> <!-- 为属性赋值 通过属性注入: 通过 setter 方法注入属性值 --> <property name="name" value="Tom"></property> </bean> </beans>
View Code
bean的实例化：Main.java
package com.ray.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
//1. 创建 Spring 的 IOC 容器，ApplicationContext代表IoC容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
/*2. 从 IOC 容器中获取 bean 的实例
2.1利用id定位到IoC容器中的bean
*/
HelloWorld helloWorld = (HelloWorld) ctx.getBean("helloWorld");
//2.2利用类型返回IoC容器中的bean，但要求IoC容器中必须只有一个该类型的bean
//HelloWorld helloWorld = (HelloWorld) ctx.getBean("helloWorld");
//3. 使用 bean
helloWorld.hello();
}
}View Code
2. bean的依赖注入
Spring 支持 3 种依赖注入的方式：属性注入、构造器注入、工厂方法注入（很少使用，不推荐）
2.1 属性注入
属性注入即通过 setter 方法注入Bean 的属性值或依赖的对象
属性注入是实际应用中最常用的注入方式。
<?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:util="http://www.springframework.org/schema/util" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"> <bean id="helloWorld" class="com.ray.spring.HelloWorld"> <!-- 通过属性注入: 通过 setter 方法注入属性值 <property>节点：设置属性 name ：指定 Bean 的属性名称 value 或 <value> 子节点：指定属性值 --> <property name="name" value="Tom"></property> </bean> </beans>
View Code
2.2 构造器注入
构造器注入即 通过配置构造器参数，来注入Bean 的属性值或依赖的对象，它保证了 Bean 实例在实例化后就可以使用。
Java bean： Car.java
package com.ray.spring;
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;
}
@Override
public String toString() {
return "Car [brand=" + brand + ", corp=" + corp + ", price=" + price
+ ", maxSpeed=" + maxSpeed + "]";
}
}View Code
配置文件： applicationContext.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:util="http://www.springframework.org/schema/util" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"> <!-- 通过构造器注入属性值 1.按参数顺序注入--> <bean id="car1" class="com.ray.spring.Car"> <!-- 都要求: 在 Bean 中必须有对应的构造器. --> <constructor-arg value="Audi"></constructor-arg> <constructor-arg value="ShangHai"></constructor-arg> <constructor-arg value="300000"></constructor-arg> </bean> <!--2.通过参数索引注入--> <bean id="car2" class="com.ray.spring.Car"> <constructor-arg value="Audi" index="0"></constructor-arg> <constructor-arg value="ShangHai" index="1"></constructor-arg> <constructor-arg value="300000" type="double"></constructor-arg> </bean> <!--3.通过参数类型注入--> <bean id="car3" class="com.ray.spring.Car"> <constructor-arg value="Audi" type="java.lang.String"></constructor-arg> <constructor-arg value="ShangHai" type="java.lang.String"></constructor-arg> <constructor-arg value="300000" type="int"></constructor-arg> </bean> </beans>
View Code
bean的实例化：
package com.ray.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
//1. 创建 Spring 的 IOC 容器，ApplicationContext代表IoC容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//2. 从 IOC 容器中获取 bean 的实例
Car car=(Car)ctx.getBean("car1");
System.out.println(car);
car=(Car)ctx.getBean("car2");
System.out.println(car);
car=(Car)ctx.getBean("car3");
System.out.println(car);
}
}View Code
3.注入参数详解
3.1 字面值
（1） 字面值：可用字符串表示的值，可以通过 <value> 元素标签或 value 属性进行注入。
（2）基本数据类型及其封装类、String 等类型都可以采取字面值注入的方式
（3） 若字面值中包含特殊字符，可以使用 <![CDATA[]]> 把字面值包裹起来。
<bean id="car3" class="com.ray.spring.Car"> <constructor-arg value="Baoma" type="java.lang.String"></constructor-arg> <constructor-arg type="java.lang.String"> <value><![CDATA[<ShangHai^>]]></value> </constructor-arg> <constructor-arg value="250" type="int"></constructor-arg> </bean>
View Code
3.2 引用其他bean
组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能. 要使 Bean 能够相互访问, 就必须在 Bean 配置文件中指定对 Bean 的引用
实体类：Car.java
package com.ray.spring;
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;
}
@Override
public String toString() {
return "Car [brand=" + brand + ", corp=" + corp + ", price=" + price
+ ", maxSpeed=" + maxSpeed + "]";
}
}View Code
Person.java
package com.ray.spring;
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;
}
public Person() {
}
public Person(String name, int age, Car car) {
super();
this.name = name;
this.age = age;
this.car = car;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
}
}View Code
两种方式：
（1）使用property的 ref 属性 ： 在 Bean 的配置文件中, 可以通过 <ref> 元素或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用.
配置文件： applicationContext.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:util="http://www.springframework.org/schema/util" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"> <bean class="com.ray.spring.Car"> <constructor-arg value="Audi"></constructor-arg> <constructor-arg value="ShangHai"></constructor-arg> <constructor-arg value="300000"></constructor-arg> </bean> <!--1.通过ref属性引用--> <bean class="com.ray.spring.Person"> <property name="name" value="Tom"></property> <property name="age" value="24"></property> <property name="car" ref="car1" ></property> </bean> <!--2.通过<ref>标签引用--> <bean class="com.ray.spring.Person"> <property name="name" value="Jack"></property> <property name="age" value="22"></property> <property name="car" > <ref bean="car1" /> </property> </bean> <!--3.通过ref属性引用（构造器注入方式）--> <bean class="com.ray.spring.Person"> <constructor-arg value="jerry"></constructor-arg> <constructor-arg value="25"></constructor-arg> <constructor-arg ref="car1"></constructor-arg> </bean> </beans>
View Code
（2）内部bean ：在属性或构造器里包含 Bean 的声明, 这样的 Bean 称为内部 Bean
<?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:util="http://www.springframework.org/schema/util" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"> <bean id="person1" class="com.ray.spring.Person"> <property name="name" value="Tom"></property> <property name="age" value="24"></property> <property name="car"> <!--内部bean --> <bean class="com.ray.spring.Car"> <constructor-arg value="Ford"></constructor-arg> <constructor-arg value="ChangAn"></constructor-arg> <constructor-arg value="200000"></constructor-arg> </bean> </property> </beans>
View Code
3.3 null值和级联属性
null
<bean id="person3" class="com.ray.spring.Person"> <constructor-arg value="jerry"></constructor-arg> <constructor-arg value="25"></constructor-arg> <!-- 赋值null--> <constructor-arg ><null/></constructor-arg> </bean>
View Code
级联属性
<bean id="person3" class="com.ray.spring.Person"> <constructor-arg value="jerry"></constructor-arg> <constructor-arg value="25"></constructor-arg> <!--为级联属性赋值，注意：属性要先初始化后才能为级联属性赋值，否则会抛异常，与struts2不同--> <constructor-arg ref="car1"></constructor-arg> <property name="car1.maxSpeed" value="250"></property> </bean>
View Code
3.4 集合属性
在 Spring中可以通过一组内置的 xml 标签(例如: <list>, <set> 或 <map>) 来配置集合属性.
（1）List属性配置： 配置 java.util.List 类型的属性, 需要指定 <list> 标签, 在标签里包含一些元素. 这些标签可以通过 <value> 指定简单的常量值,
通过 <ref> 指定对其他 Bean 的引用. 通过<bean> 指定内置 Bean 定义. 通过 <null/> 指定空元素. 甚至可以内嵌其他集合.
实体类：Car.java
package com.ray.spring.collections;
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;
}
@Override
public String toString() {
return "Car [brand=" + brand + ", corp=" + corp + ", price=" + price
+ ", maxSpeed=" + maxSpeed + "]";
}
}View Code
Person.java
package com.ray.spring.collections;
import java.util.List;
public class Person {
private String name;
private int age;
private List<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 List<Car> getCars() {
return cars;
}
public void setCars(List<Car> cars) {
this.cars = cars;
}
public Person() {
}
public Person(String name, int age, List<Car> cars) {
super();
this.name = name;
this.age = age;
this.cars = cars;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", cars=" + cars + "]";
}
}View Code
配置文件： applicationContext.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:util="http://www.springframework.org/schema/util" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"> <bean id="car1" class="com.ray.spring.Car"> <constructor-arg value="Audi"></constructor-arg> <constructor-arg value="ShangHai"></constructor-arg> <constructor-arg value="300000"></constructor-arg> </bean> <bean id="car2" class="com.ray.spring.Car"> <constructor-arg value="Audi" index="0"></constructor-arg> <constructor-arg value="ShangHai" index="1"></constructor-arg> <constructor-arg value="500000" type="double"></constructor-arg> </bean> <bean id="car3" class="com.ray.spring.Car"> <constructor-arg value="Baoma" type="java.lang.String"></constructor-arg> <constructor-arg value="ShangHai" type="java.lang.String"></constructor-arg> <constructor-arg value="250" type="int"></constructor-arg> </bean> <bean id="person1" class="com.ray.spring.collections.Person"> <property name="name" value="Tom"></property> <property name="age" value="24"></property> <!--配置集合属性--> <property name="cars" > <list> <ref bean="car1" /> <ref bean="car2" /> <ref bean="car3" /> </list> </property> </bean> </beans>
View Code
bean的实例化：Main.java
package com.ray.spring.collections;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person=(Person)ctx.getBean("person1");
System.out.println(person);
}
}View Code
(2)数组的定义和 List 一样, 都使用 <list>
(3)配置 java.util.Set 需要使用 <set> 标签, 定义元素的方法与 List 一样.
(4)Map属性配置： Java.util.Map 通过 <map> 标签定义, <map> 标签里可以使用多个 <entry> 作为子标签. 每个条目包含一个键和一个值. 必须在 <key> 标签里定义键因为键和值的类型没有限制, 所以可以自由地为它们指定 <value>, <ref>, <bean> 或 <null> 元素.
可以将 Map 的键和值作为 <entry> 的属性定义: 简单常量使用 key 和 value 来定义; Bean 引用通过 key-ref 和 value-ref 属性定义；
使用 <props> 定义： Map的子类 java.util.Properties, 该标签使用多个 <prop> 作为子标签. 每个 <prop> 标签必须定义 key 属性.
实体类：Car.java
package com.ray.spring.collections;
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;
}
@Override
public String toString() {
return "Car [brand=" + brand + ", corp=" + corp + ", price=" + price
+ ", maxSpeed=" + maxSpeed + "]";
}
}View Code
Person.java
package com.ray.spring.collections;
import java.util.Map;
public class Person {
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;
}
public Person() {
}
public Person(String name, int age, Map<String, Car> cars) {
super();
this.name = name;
this.age = age;
this.cars = cars;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", cars=" + cars + "]";
}
}View Code
DataSource.java
package com.ray.spring.collections;
import java.util.Properties;
public class DataSource {
private Properties properties;
public Properties getProperties() {
return properties;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
@Override
public String toString() {
return "DataSource [properties=" + properties + "]";
}
}View Code
配置文件： applicationContext.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:util="http://www.springframework.org/schema/util" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"> <bean id="car1" class="com.ray.spring.Car"> <constructor-arg value="Audi" index="0"></constructor-arg> <constructor-arg value="ShangHai" index="1"></constructor-arg> <constructor-arg value="300000" type="double"></constructor-arg> </bean> <bean id="car2" class="com.ray.spring.Car"> <constructor-arg value="Baoma" type="java.lang.String"></constructor-arg> <constructor-arg value="ShangHai" type="java.lang.String"></constructor-arg> <constructor-arg value="250" type="int"></constructor-arg> </bean> <bean id="car3" class="com.ray.spring.Car"> <constructor-arg value="Baoma" type="java.lang.String"></constructor-arg> <constructor-arg type="java.lang.String"> <value><![CDATA[<ShangHai^>]]></value> </constructor-arg> <constructor-arg value="250" type="int"></constructor-arg> </bean> <bean id="person1" class="com.ray.spring.collections.Person"> <property name="name" value="Rose"></property> <property name="age" value="28"></property> <!--1.使用map节点及map的entry子节点配置Map类型的成员变量--> <property name="cars" > <map> <entry key="A" value-ref="car1"></entry> <entry key="B" value-ref="car2"></entry> <entry key="C" value-ref="car3"></entry> </map> </property> </bean> <!-- 2.配置Properties属性值--> <bean id="dataSource" class="com.ray.spring.collections.DataSource"> <peoperty name="properties"> <!-- 使用props 和prop子节点来为Properties属性赋值--> <props> <prop key="user">root</prop> <prop key="password">123</prop> <prop key="jdbcUrl">jdbc:mysql:///test</prop> <prop key="driverClass">com.mysql.jdbc.Driver</prop> </props> </property> </bean> <!--3.配置单例的集合bean，以供多个bean进行引用，需要导入util命名空间--> <util:list id="cars"> <ref bean="car1"/> <ref bean="car2"/> </util:list> <bean id="person2" class="com.ray.spring.collections.Person"> <property name="name" value="jack"></property> <property name="age" value="29"></property> <property name="cars" ref="cars"></property> </bean> </beans>
View Code
bean的实例化：Main.java
package com.ray.spring.collections;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person=(Person)ctx.getBean("person1");
System.out.println(person);
DataSource datasource=(DataSource)ctx.getBean("dataSource");
System.out.println(datasource);
}
}View Code
3.5 p命名空间
配置文件： applicationContext.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:util="http://www.springframework.org/schema/util" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"> <bean id="car1" class="com.ray.spring.Car"> <constructor-arg value="Audi" index="0"></constructor-arg> <constructor-arg value="ShangHai" index="1"></constructor-arg> <constructor-arg value="300000" type="double"></constructor-arg> </bean> <bean id="car2" class="com.ray.spring.Car"> <constructor-arg value="Baoma" type="java.lang.String"></constructor-arg> <constructor-arg value="ShangHai" type="java.lang.String"></constructor-arg> <constructor-arg value="250" type="int"></constructor-arg> </bean> <!--3.配置单例的集合bean，以供多个bean进行引用，需要导入util命名空间--> <util:list id="cars"> <ref bean="car1"/> <ref bean="car2"/> </util:list> <!--4.通过 p 命名空间为bean的属性赋值，需要先导入 p 命名空间--> <bean id="person5" class="com.ray.spring.collections.Person" p:age="30" p:name="Queen" p:cars-ref="cars"></bean> </beans>
View Code
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Spring总结_04_容器和bean
- Spring总结_04_容器和bean
- Spring总结_04_容器和bean
- Spring总结_04_容器和bean
- Spring总结_04_容器和bean
- 传智播客 Spring中bean的实例化方式与IOC容器总结
- Spring中bean的实例化方式与IOC容器总结
- spring容器注入错误总结Cannot resolve reference to bean '***' while setting bean property 'ref'
- JSP 获取spring容器中bean的两种方法总结
- Spring学习总结（6）——Spring之核心容器bean
- Quartz任务中调用Spring容器中bean及动态调度任务
- Spring学习总结3（bean的属性详解）
- spring学习笔记整理--04(配置Spring管理的bean的作用域、生命周期)
- Java类获取spring 容器的bean
- 获取Spring 容器中bean的方法
- 如何通过代码直接获得Spring容器中的Bean?
- Spring FrameWork 总结-- 容器和bean
- mybatis-spring整合总结02_SqlSessionFactoryBean
- Spring+Servlet整合(如何向Servlet注入属性(转),servlet获取spring容器中的bean)
- Spring(基础)学习文档四(spring容器管理bean)