基于 XML 文件的方式配置 Bean
配置 bean
主要内容：
- 配置形式：基于 XML 文件的方式；基于注解的方式（基于注解配置 bean ；基于注解来装配 bean 的属性）。
- Bean 的配置方式：通过全类名（反射）、通过工厂方法（静态工厂方法&实例工厂方法）、FactoryBean。
- IOC 容器 BeanFactory & ApplicationContext 概述。
- 依赖注入的方式：属性注入；构造器注入。
- 注入属性值细节。
- 自动装配。
- bean 之间的关系：继承；依赖。
- bean 的作用域：singleton；prototype；WEB 环境作用域。
- 使用外部属性文件。
- spEL。
- IOC 容器中 Bean 的生命周期。
- Spring 4.x 新特性：泛型依赖注入。
基于 XML 文件的方式：
1、在 Spring 的 IOC 容器里配置 Bean
在 xml 文件中通过 bean节点来配置 bean。
<!-- 配置 bean class：bean 的全类名，通反射的方式在 IOC 容器中创建 Bean，所以要求 Bean 中必须有无参构造方法 id：标识容器中的 bean，id唯一。 --> <bean id="helloWorld" class="com.spring.beans.HelloWorld"> <property name="name" value="Spring"/> </bean>
id：Bean 的名称。
- 在 IOC 容器中必须是唯一的
- 若 id 没有指定，Spring 自动将权限定性类名作为 Bean 的名字
- id 可以指定多个名字，名字直渐可用逗号、分号、或空格分隔
2、Spring 容器
- 在 Spring IOC 容器读取 Bean 配置创建 Bean 实例之前，必须对它进行实例化。只有在容器实例化后，才可以从 IOC 容器里获取 Bean 实例并使用。
Spring 提供了两种类型的 IOC 容器实现。
- BeanFactory：IOC 容器的基本实现。
- ApplicationContext：提供了更多的高级特性，是 BeanFactory 的子接口。
BeanFactory 是 Spring 框架的基础设施，面向 Spring 本身；
ApplicationContext 面向使用 Spring 框架的开发者，几乎所有的应用场合都直接使用 ApplicationContext 而非底层的 BeanFactory。
- 无论使用何种方式，配置文件时都相同的。
ApplicationContext
ApplicationContext 的主要实现类：
— ClassPathXmlApplicationContext：从类路径下加载配置文件
— FileSystemXmlApplicationContext：从文件系统中加载配置文件
- ConfigurableApplicationContext 扩展于 ApplicationContext，新增两个主要方法：refresh() 和 close()，让 ApplicationContext 具有启动、刷新和关闭上下文的能力
- ApplicationContext 在初始化上下文时就实例化所有单例的 Bean。
- WebApplicationContext 是专门为 WEB 应用而准备的，它允许从相对于 WEB 根目录的路径中完成初始化工作。
getBean() 方法
参数有两种
参数是 Bean 的 id；
利用 id 定位到 IOC 容器中的
beanHelloWorld helloWorld = (HelloWorld) ctx.getBean("helloWorld");
参数是 类名.class；
利用类型返回 IOC 容器中的 Bean，但要求 IOC 容器中只能有一个该类型的 Bean
HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
3、依赖注入的方式
属性注入
- 属性注入即通过 setter 方法注入 Bean 的属性值或依赖的对象
- 属性注入使用 <property> 元素，使用 name 属性指定 Bean 的属性名称，value 属性或 <value> 子节点指定属性值
属性注入是实际应用中最常用的注入方式
<bean id="helloWorld" class="com.spring.beans.HelloWorld"> <property name="name" value="Spring"/> </bean>
构造方法注入
- 通过构造方法注入 Bean 的属性值或依赖的对象，它保证了 Bean 实例在实例化后就可以使用。
构造器注入在 <constructor-arg> 元素里生命属性
<constructor-arg> 中没有 name 属性
public class Car { private String brand; private String corp; private double price; private int maxSpeed; @Override public String toString() { return "Car{" + "brand='" + brand + '\'' + ", corp='" + corp + '\'' + ", price=" + price + ", maxSpeed=" + maxSpeed + '}'; } public Car(String brand, String corp, double price) { this.brand = brand; this.corp = corp; this.price = price; } public Car(String brand, String corp, int maxSpeed) { this.brand = brand; this.corp = corp; this.maxSpeed = maxSpeed; } }<!--<bean id="car" class="com.spring.beans.Car"> <constructor-arg value="Audi" index="0"/> <constructor-arg value="ShangHai" index="1"/> <constructor-arg value="300000" index="2"/> </bean>--> <bean id="car" class="com.spring.beans.Car"> <constructor-arg value="Audi" type="java.lang.String"/> <constructor-arg value="ShangHai" type="java.lang.String"/> <constructor-arg value="300000" type="double"/> </bean> <bean id="car2" class="com.spring.beans.Car"> <constructor-arg value="BaoMa" type="java.lang.String"/> <constructor-arg value="ShangHai" type="java.lang.String"/> <constructor-arg value="300000" type="int"/> </bean>其中 index 表示构造函数中参数的位置，type 表示类型。以区分重载的构造函数。
- 工厂方法注入（很少使用，不推荐）
4、注入属性值的细节
字面值：可用字符串表示的值，可以通过 <value> 元素标签或 value 属性进行注入。
<bean id="car2" class="com.spring.beans.Car"> <constructor-arg value="BaoMa" type="java.lang.String"/> <constructor-arg value="ShangHai" type="java.lang.String"/> <constructor-arg type="int"> <value>250</value> </constructor-arg> </bean>
- 基本数据类型及其封装类、String 等类型都可以采取字面值注入方式。
若字面值中包含特殊字符，可以使用 <![CDATA[]]> 把字面值包裹起来。
<bean id="car2" class="com.spring.beans.Car"> <constructor-arg value="BaoMa" type="java.lang.String"/> <constructor-arg type="java.lang.String"> <value><![CDATA[<ShangHai^>]]></value> </constructor-arg> <constructor-arg type="int"> <value>250</value> </constructor-arg> </bean>
5、引用其它 Bean
- 组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能，要使 Bean 能够相互访问，就必须在 Bean 配置文件中指定对 Bean 的引用。
在 Bean 的配置文件中，可以通过 <ref> 或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用。
<bean id="person" class="com.spring.beans.Person"> <property name="name" value="Tom"/> <property name="age" value="24"/> <!--<property name="car" ref="car2"/>--> <property name="car"> <ref bean="car2"/> </property> </bean>
也可以在属性或构造器里包含 Bean 的声明，这样的 Bean 称为內部 Bean。
在属性内使用內部 Bean：
<bean id="person" class="com.spring.beans.Person"> <property name="name" value="Tom"/> <property name="age" value="24"/> <!--<property name="car" ref="car2"/>--> <!--<property name="car">--> <!-- <ref bean="car2"/>--> <!--</property>--> <property name="car"> <bean class="com.spring.beans.Car"> <constructor-arg value="Ford"/> <constructor-arg value="ChangAn"/> <constructor-arg value="200000" type="double"/> </bean> </property> </bean>在构造器内使用內部 Bean：
public Person() { } public Person(String name, int age, Car car) { this.name = name; this.age = age; this.car = car; }<bean id="person2" class="com.spring.beans.Person"> <constructor-arg value="Jerry"/> <constructor-arg value="25"/> <constructor-arg ref="car"/> </bean>！注意：当 Bean实例仅仅给一个特定的属性使用时，可以将其声明为內部 Bean。內部 Bean 声明直接包含在 <property> 或 <constructor-arg> 元素里，不需要设置任何 id 或 name 属性。內部 Bean 不能使用在其他任何地方。
6、注入参数详解：null 值和级联属性
可以使用专用的 <null/> 元素标签为 Bean 的字符串或其它对象类型的属性注入 bull 值
<bean id="person2" class="com.spring.beans.Person"> <constructor-arg value="Jerry"/> <constructor-arg value="25"/> <!--<constructor-arg ref="car"/>--> <constructor-arg><null/></constructor-arg> </bean>和 Struts、Hiberante 等框架一样，Spring 支持级联属性的配置
<bean id="person2" class="com.spring.beans.Person"> <constructor-arg value="Jerry"/> <constructor-arg value="25"/> <!--<constructor-arg ref="car"/>--> <!--<constructor-arg><null/></constructor-arg>--> <constructor-arg ref="car2"/> <property name="car.maxSpeed" value="250"/> </bean>！注意：属性需要先初始化后才可以为级联属性赋值，否则会有异常，和 Struts2 不同。
7、集合属性
- 在 Spring 中可以通过一组内置的 xml 标签（例如：<list> , <set> , <map> ）来配置集合属性。
- 配置 Java.util.List 类型的属性，需要指定 <list> 标签，在标签里包含一些元素。这些标签可以通过 <value> 指定简单的常量值，通过<ref> 指定对其他 Bean 的引用。通过 <bean> 指定内置 Bean 定义。通过 <null/> 指定空元素。甚至可以内嵌其他集合。
- 数组的定义和 List 一样，都使用 <list> 。
配置 java.util.Set 需要使用 <set> 标签，定义元素的方法与 List 一样。
<!-- 使用 list 节点为 List 类型的属性赋值 --> <bean id="person3" class="com.spring.beans.collections.Person"> <property name="name" value="Mike"/> <property name="age" value="27"/> <property name="cars"> <list> <ref bean="car"/> <ref bean="car2"/> </list> </property> </bean> <!-- 使用 list 节点为 List 类型的属性赋值(內部 Bean) --> <bean id="person3" class="com.spring.beans.collections.Person"> <property name="name" value="Mike"/> <property name="age" value="27"/> <property name="cars"> <list> <ref bean="car"/> <ref bean="car2"/> <bean class="com.spring.beans.Car"> <constructor-arg value="Ford"/> <constructor-arg value="ChangAn"/> <constructor-arg value="200000" type="double"/> </bean> </list> </property> </bean>
- Java.util.Map 通过 <map> 标签定义，<map> 标签里可以使用多个 <entry> 作为子标签。每个条目包含一个键和一个值。
- 必须在 <key> 标签里定义键
- 因为键和值的类型没有限制，所以可以自由地为它们指定 <value> ，<ref> ，<bean> 或 <null> 元素。
- 可以将 Map 的键和值作为 <entry> 的属性定义；简单常量使用 key 和 value 来定义；Bean 引用通过 key-ref 和 value-ref 属性定义
使用 <props> 定义 java.util.Properties，该标签使用多个 <prop> 作为子标签。每个 <prop> 标签必须定义 key 属性。
<!-- 使用 map 节点及 map 的 entry 子节点配置 Map 类型的成员变量 --> <bean id="newPerson" class="com.spring.beans.collections.NewPerson"> <property name="name" value="Rose"/> <property name="age" value="28"/> <property name="cars"> <map> <entry key="AA" value-ref="car"/> <entry key="BB" value-ref="car2"/> </map> </property> </bean> <!-- 使用 props 和 prop 子节点来为 Properties 属性赋值 --> <bean id="dataSource" class="com.spring.beans.collections.DataSource"> <property name="properties"> <props> <prop key="user">root</prop> <prop key="password">1234</prop> <prop key="jdbcUel">jdbc:mysql:///test</prop> <prop key="driverClass">com.mysql.jdbc.Driver</prop> </props> </property> </bean>
8、使用 utility schema 定义集合
使用基本的集合标签定义集合时，不能将集合作为独立的 Bean 定义，导致其他 Bean 无法引用该集合，所以无法在不同 Bean 之间共享集合。
<!-- 配置独立的集合 bean，以供多个 bean 进行引用，需要导入 util 命名空间 --> <util:list id="cars"> <ref bean="car"/> <ref bean="car2"/> </util:list> <bean id="person4" class="com.spring.beans.collections.Person"> <property name="name" value="Jack"/> <property name="age" value="29"/> <property name="cars" ref="cars"/> </bean>- 可以使用 util schema 里的集合标签定义独立的集合 Bean 。需要注意的是，必须在 <beans> 根元素里添加 util schema 定义。
9、使用 p 命名空间
- 为了简化 XML 文件的配置，越来越多的 XML 文件采用属性而非子元素配置信息。
- Spring 从 2.5 版本开始引用了一个新的 p 命名空间，可以通过 <bean> 元素属性的方式配置 Bean 的属性。
使用 p 命名空间后，基于 XML 的配置方式将进一步简化。
<!-- 通过 p 命名空间为 bean 的属性赋值，需要先导入 p 命名空间，相对于传统的配置方式更加的简洁 --> <bean id="person5" class="com.spring.beans.collections.Person" p:name="Queen" p:age="30" p:cars-ref="cars"/>
10、XML 配置里的 Bean 自动装配
- Spring IOC 容器可以自动装配 Bean。需要做的仅仅是在 <bean> 的 autowire 属性里指定自动装配的模式
- byType（根据类型自动装配）：若 IOC 容器中有多个与目标 Bean 类型一致的 Bean。在这种情况下，Spring 将无法判定哪个 Bean 最合适该属性，所以不能执行自动装配。
- byName（根据名称自动装配）：必须将目标 Bean 的名称和属性名设置的完全相同。
constructor（通过构造器自动装配）：当 Bean 中存在多个构造器时，此种自动装配方式将会很复杂，不推荐使用。
<bean id="address" class="com.spring.beans.autowire.Address" p:city="Beijing" p:street="HuiLongGuan"/> <bean id="car" class="com.spring.beans.autowire.Car" p:brand="Audi" p:price="300000"/> <!--手工装配--> <bean id="person" class="com.spring.beans.autowire.Person" p:name="Tom" p:address-ref="address" p:car-ref="car"/> <!--自动装配--> <!--byName: 根据名字自动装配，要求 xml 文件里的 bean 的 id 与当前 bean 的 setter 风格的属性名进行自动装配，若有匹配的，则进行自动装配；若没有匹配的，则不装配。--> <bean id="person" class="com.spring.beans.autowire.Person" autowire="byName"/> <!--byType: 根据 bean 的类型和当前 bean 的属性的类型进行自动装配，若 IOC 容器中有一个以上的类型匹配的 bean，则抛异常。--> <bean id="person" class="com.spring.beans.autowire.Person" autowire="byType"/>
XML 配置里的 Bean 自动装配的缺点
- 在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配 Bean 的所有属性。然而，若只希望装配个别属性时，autowire 属性就不够灵活了。
- autowire 属性要么根据类型自动装配，要么根据名称自动装配，不能两者兼而有之。
- 一般情况下，在实际的项目中很少使用自动装配功能，因为和自动装配功能所带来的好处比起来，明确清晰的配置文档更有说服力。
11、bean 之间的关系
继承 Bean 的配置
- Spring 允许继承 bean 的配置，被继承的 bean 称为父 bean。继承这个父 bean 的 bean 称为子 bean。
- 子 Bean 从父 Bean中继承配置，包括 Bean 的属性配置
子 Bean 也可以覆盖从父 Bean 继承过来的配置
<bean id="address" class="com.spring.beans.autowire.Address" p:city="Beijing^" p:street="WuDaoKou"/> <!--bean 配置的继承：使用 bean 的 parent 属性指定继承哪个 bean 配置--> <!-- 三种例子 --> <bean id="address2" parent="address"/> <bean id="address2" p:street="DaZhongSi" parent="address"/> <bean id="address2" p:city="Beijing" p:street="DaZhongSi" parent="address"/>父 Bean 可以作为配置模板，也可以作为 Bean 实例。若只想把父 Bean 作为模板，可以设置 <bean> 的 abstract 属性为 true，这样 Spring 将不会实例化这个 Bean。
<!-- abstract = true 时，该 bean 称为抽象 bean。这样的 bean 不能被 IOC 容器实例化，只用来被继承配置 --> <bean id="address" class="com.spring.beans.autowire.Address" p:city="Beijing^" p:street="WuDaoKou" abstract="true"/>- 并不是 <bean> 元素里的所有属性都会被继承。比如：autowire，abstract等。
也可以忽略父 Bean 的 class 属性，让子 Bean 指定自己的类，而共享相同的属性配置。但此时 abstract 必须设为 true。
<!-- 若某一个 bean 的 class 属性没有指定，则该 bean 必须是一个抽象 bean --> <bean id="address" abstract="true" p:city="Beijing^" p:street="WuDaoKou"/> <!--bean 配置的继承：使用 bean 的 parent 属性指定继承哪个 bean 配置--> <bean id="address2" class="com.spring.beans.autowire.Address" parent="address"/>
依赖 Bean 的配置
- Spring 允许用户通过 depends-on 属性设定 Bean 前置依赖的 Bean，前置依赖的 Bean 会在本 Bean 实例化之前创建好。
- 如果前置依赖于多个 Bean，则可以通过逗号，空格或的方式配置 Bean 的名称。
在实际应用中实例化某个 bean 时，经常要在实例化该 bean 之前实例化另外一个 bean，因此产生了依赖关系。
<!--要求再配置 Person 时，必须有一个关联的 Car。--> <bean id="person" class="com.spring.beans.autowire.Person" p:name="Tom" p:address-ref="address2" depends-on="car"/> <bean id="car" class="com.spring.beans.autowire.Car" p:brand="Audi" p:price="300000"/>注意：depends-on = ” car ” 只是指定了在获取 person 的 bean 时，要现在 IOC 容器中能获取 car 的 bean，但是并不是说就把 car 的 bean 注入到了 person 的 bean 中了，要想 person 用有 car 的 bean，需要在 person 的 bean 的配置中获取 car 的 bean。
12、bean 的作用域
- 使用 bean 的 scope 属性来配置 bean 的作用域
singleton：默认值，容器初始化时创建 bean 实例，在整个容器的生命周期内只创建这一个 bean. 单例的。
<bean id="car" class="com.spring.beans.autowire.Car" scope="singleton"> <property name="brand" value="Audi"/> <property name="price" value="300000"/> </bean>prototype：原型的，容器初始化时不创建 bean 的实例，而在每次请求时都创建一个新的 bean 实例，并返回。
<bean id="car" class="com.spring.beans.autowire.Car" scope="prototype"> <property name="brand" value="Audi"/> <property name="price" value="300000"/> </bean>
13、使用外部属性文件
- 在配置文件里配置 bean 时，有时需要在 bean 的配置里混入系统部署的细节信息(例如：文件路径，数据源配置信息等)。而这些部署细节实际上需要和 bean 的配置相分离。
- Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器，这个处理器允许用户将 Bean 配置的部分内容外移到属性文件中。可以在 bean 配置文件里使用形式为 ${var} 的变量， PropertyPlaceholderConfigurer 从属性文件里加载属性，并使用这些属性来替换变量。
Spring 还允许在属性文件中使用 ${propName}，以实现属性之间的相互吸引。
xml 文件：
<!--导入属性文件--> <context:property-placeholder location="db.properties"/> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <!--使用外部化属性文件的属性--> <property name="user" value="${user}"/> <property name="password" value="${password}"/> <property name="driverClass" value="${driverClass}"/> <property name="jdbcUrl" value="${jdbcUrl}"/> </bean>properties 文件：
user=root password=jie13727507037 driverClass=com.mysql.cj.jdbc.Driver jdbcUrl=jdbc:mysql:///text?serverTimezone=UTC注意：mysql-connector-java 5版本之后的 driverClass 使用 com.mysql.cj.jdbc.Driver，同时还要在 jdbcUrl 后面加上 ?serverTimezone=UTC。
14、Spring 表达式语言：SpEL
Spring 表达式语言（简称 SpEL ）：是一个支持运行时查询和操作对象图的强大表达式语言。
语法类似于 EL：SpEL 使用 #{...} 作为定界符，所有在大括号中的字符都将被认为是 SpEL。
SpEL 为 bean 的属性进行动态赋值提供了便利。
通过 SpEL 可以实现：
赋字面值，如：int string Boolean double等类型的值
<bean id="address" class="com.spring.beans.spel.Address"> <!--使用 spel 为属性赋一个字面值--> <property name="city" value="#{'BeiJing'}"/> <property name="street" value="WuDaoKou"/> </bean>通过 bean 的 id 对 bean 进行引用
- 引用其他对象
调用方法以及引用对象中的属性
- 引用其他对象的属性
- 调用其他方法，还可以链式操作
调用静态方法或静态属性：通过 T() 调用一个类的静态方法，它将返回一个 Class Object，然后再调用相应的方法或属性
<bean id="car" class="com.spring.beans.spel.Car"> <property name="brand" value="Audi"/> <property name="price" value="500000"/> <!--使用 spel 引用类的静态属性--> <property name="tyrePerimeter" value="#{T(java.lang.Math).PI * 80}"/> </bean>
计算表达式的值
- 算术运算符：+，-，*，/，%，^；
- 加号还可以用作字符串连接
- 比较运算符：<，>，==，<=，>=；
- 逻辑运算符：and，or，not
- if-else（相当于三目运算符）运算符：?:(temary), ?:(Elvis)
- if-else（相当于三目运算符）的变体
- 正则表达式：matches
正则表达式的匹配
<bean id="person" class="com.spring.beans.spel.Person"> <!--<property name="car" ref="car"/>--> <!--使用 spel 来引用其他的 bean--> <property name="car" value="#{car}"/> <!--使用 spel 来引用其他 bean 的属性--> <property name="city" value="#{address.city}"/> <!--在 spel 中使用运算符--> <property name="info" value="#{car.price > 300000 ? '金领' : '白领'}"/> <property name="name" value="Tom"/> </bean>
15、IOC 容器中 Bean 的生命周期方法
- Spring IOC 容器可以管理 Bean 的生命周期，Spring 允许在 Bean 生命周期的特定点执行定制的任务。
Spring IOC 容器对 Bean 的生命周期进行管理的过程：
- 通过构造器或工厂方法创建 Bean 实例
- 为 Bean 的属性设置值和其他 Bean 的引用
- 调用 Bean 的初始化方法
- Bean 可以使用了
- 当容器关闭时，调用 Bean 的销毁方法
在 Bean 的声明里设置 init-method 和 destroy-method 属性，为 Bean 指定初始化和销毁方法。
xml 代码：
<bean id="car" class="com.spring.beans.cycle.Car" init-method="init" destroy-method="destroy"> <property name="brand" value="Audi"/> </bean>java 代码：
public static void main(String[] args) { //将 ctx 转换成 ClassPathXmlApplicationContext 类型才有关闭 IOC 容器的 close() 方法 ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans-cycle.xml"); Car car = (Car) ctx.getBean("car"); System.out.println(car); //关闭 IOC 容器 ctx.close(); }
创建 bean 的后置处理器
- Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理。
- Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理，而非单一实例。其典型应用是：检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性。
对 Bean 后置处理器而言，需要实现 Interface BeanPostProcessor 接口。在初始化方法被调用前后，Spring 将把每个 Bean 实例分别传递给上述接口的一下两个方法：
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { return null; }public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return null; }
Spring IOC 容器对 Bean 的生命周期进行管理的过程：
- 通过构造器或工厂方法创建 Bean 实例
- 为 Bean 的属性设置值和其他 Bean 的引用
- 将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法
- 调用 Bean 的初始化方法
- 将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization 方法
- Bean 可以使用了
- 当容器关闭时，调用 Bean 的销毁方法
<!-- 实现 BeanPostProcessor 接口，并具体提供两个方法 Object postProcessBeforeInitialization(Object bean, String beanName)：init-method 之前被调用 Object postProcessAfterInitialization(Object bean, String beanName)：init-method 之后被调用 的实现 bean：bean实例本身 beanName：IOC 容器中配置的 bean 的名字 返回值：是实际上返回给用户的那个 bean，注意可以在以上两个方法中修改返回的 bean，甚至返回一个新的 bean --> <!-- 配置 bean 的后置处理器：不需要配置 id，IOC 容器自动识别是一个 BeanPostProcessor --> <bean class="com.spring.beans.cycle.MyBeanPostProcessor"/>
16、通过工厂方法配置 Bean
通过调用静态工厂方法创建 Bean
- 调用静态工厂方法创建 Bean 是将对象创建的过程封装到静态方法中。当客户端需要对象时，只需要简单地调用静态方法，而不需要关心创建对象的细节。
要声明通过静态方法创建的 Bean， 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类，同时在 factory-method 属性里指定工厂方法的名称。最后，使用 <constructor-arg> 元素为该方法传递方法参数。
/** * 静态工厂方法：直接调用某一个类的静态方法就可以返回 bean 的实例 */ public class StaticCarFactory { private static Map<String, Car> cars = new HashMap<String, Car>(); static { cars.put("audi", new Car("audi", 300000)); cars.put("ford", new Car("ford", 400000)); } //静态工厂方法： public static Car getCar(String name) { return cars.get(name); } }<!--通过静态工厂方法来配置 bean， 注意不是配置静态工厂方法实例，而是配置 bean 实例--> <!-- class 属性：指向静态工厂方法的全类名 factory-method：指向静态工厂方法的名字 constructor-arg：如果工厂方法需要传入参数，则使用 constructor-arg 来配置参数 --> <bean id="car1" class="com.spring.beans.factory.StaticCarFactory" factory-method="getCar"> <constructor-arg value="ford"/> </bean>
通过调用实例工厂方法创建 Bean
- 实例工厂方法：将对象的创建过程封装到另外一个对象实例的方法里。当客户端需要请求对象时，只需要简单的调用该实例方法而不需要关心对象的创建细节。
要声明通过实例工厂方法创建的 Bean
- 在 bean 的 factory-bean 属性里指定拥有该工厂方法的 bean
- 在 factory-method 属性里指定该工厂方法的名称
- 使用 constructor-arg 元素为工厂方法传递方法参数
/** * 实例工厂方法：实例工厂的方法，即先需要创建工厂本身，再调用工厂的实例方法来返回 bean 的实例 */ public class InstanceCarFactory { private Map<String, Car> cars = null; public InstanceCarFactory() { cars = new HashMap<String, Car>(); cars.put("audi", new Car("audi", 300000)); cars.put("ford", new Car("ford", 00000)); } public Car getCar(String brand) { return cars.get(brand); } }<!--配置工厂的实例--> <bean id="carFactory" class="com.spring.beans.factory.InstanceCarFactory"/> <!--通过实例工厂方法来配置 bean--> <!-- factory-bean：指向实例工厂方法的bean factory-method：指向实例工厂方法的名字 constructor-arg：如果工厂方法需要传入参数，则使用 constructor-arg 来配置参数 --> <bean id="car2" factory-bean="carFactory" factory-method="getCar"> <constructor-arg value="audi"/> </bean>
17、通过 FactoryBean 配置 Bean
CarFactoryBean 实现 FactoryBean 接口：
package com.spring.beans.factorybean;
import org.springframework.beans.factory.FactoryBean;
//自定义的 FactoryBean 需要实现 FactoryBean 接口
public class CarFactoryBean implements FactoryBean<Car> {
private String brand;
public void setBrand(String brand) {
this.brand = brand;
}
//返回 bean 的对象
@Override
public Car getObject() throws Exception {
return new Car(brand, 500000);
}
/**
* 返回的 bean 的类型
*/
@Override
public Class<?> getObjectType() {
return Car.class;
}
//该 bean 是否为单例的
@Override
public boolean isSingleton() {
return true;
}
}FactoryBean 的 xml 文件：
<!--
通过 FactoryBean 来配置 Bean 的实例
class：指向 FactoryBean 的全类名
property：配置 FactoryBean 的属性
但实际返回的实例却是 FactoryBean 的 getObject() 方法返回的实例！
-->
<bean id="car" class="com.spring.beans.factorybean.CarFactoryBean">
<property name="brand" value="BMW"/>
</bean>
