1 回顾Spring IoC容器
1.1 Spring IoC容器
Web应用程序由大量的程序组件组成，这些组件一起工作完成业务逻辑的执行。 这些组件通常是一个依赖另一个，互相协作实现所需功能。
Spring提供容器，也就是IoC容器，来管理这些组件，我们叫做Bean，Spring容器负责创建、初始化和销毁其管理的各种Bean，并根据Bean的依赖关系注入依赖的Bean，也就是依赖注入（DI）。
Spring IoC容器的类型：
- BeanFactory容器（Bean工厂容器） 低级容器，提供容器的基本功能，包括Bean的管理和依赖注入。由org.springframework.beans.factory.BeanFactory接口表示
- ApplicationContext容器（应用程序上下文容器） 高级容器，提供BeanFactory容器的功能，还提供一些高级的企业级功能。由org.springframework.context.ApplicationContext定义。如果没有什么特殊理由，直接使用ApplicationContext容器即可
下面给出一个例子，结合使用面向接口编程(将方法的声明/定义放入接口，将方法的具体实现放入实现类)，使用IoC实现解耦(decoupling)
假设我们有若干个动物类：狗、猪、羊，它们都要吃东西，有一个方法eat()。
我们将这个方法的定义放入接口：
public interface Animal {
void eat();
}将这个方法的具体实现放入实现类：
public class Dog implements Animal{
public Dog() {
System.out.println("实例化了Dog！！！");
}
@Override
public void eat() {
System.out.println("这是一只狗，狗吃骨头！");
}
}
使用IoC思想，将bean交给容器管理。若需要换掉使用的bean，修改spring配置文件中的bean类型即可，实现降低程序的耦合性，方便后期维护
在XML文件中定义一个bean：
<bean id="animal" class="com.qdu.bean.Dog" />在主类中，首先加载Spring配置文件，创建并启动容器
ApplicationContext ctx
=new ClassPathXmlApplicationContext("config/spring-beans.xml");需要该bean的地方通过调用getBean()或依赖注入获取bean
Animal animal1=(Animal)ctx.getBean("animal");
animal1.eat();1.2 上下文容器中bean的生命周期
1.2.1 生命周期回调
容器控制着bean的创建和销毁。
为了执行一些自定义代码，容器提供了回调方法，回调方法主要包括：
- 初始化回调的方法：用于执行一些初始化操作
- 销毁前回调的方法：用于执行一些类似释放资源的操作
1.2.2 控制Bean的生命周期事件
Spring框架提供了以下方法来控制Bean的生命周期事件：
- InitializingBean和DisposableBean回调接口
- 可用于注入特定依赖的Aware接口
- bean配置文件中的自定义init（）和destroy（）方法
- @PostConstruct 和 @PreDestroy注解
a. 使用InitializingBean和DisposableBean回调接口，实现初始化和释放资源任务。
- 有的时候，使用一个bean之前可能需要执行一些初始化工作（准备工作）,就可以利用bean的初始化回调方法执行初始化操作。可以通过实现InitializingBean接口，实现afterPropertiesSet()方法，在该方法中编写初始化工作代码
- 有的时候，一个bean被摧毁之前需要释放这个bean占用的资源，就可以利用bean的摧毁回调方法来执行释放操作。可通过实现DisposableBean接口，实现destroy()方法，在该方法中编写bean摧毁之前要执行的工作
public class Pig implements InitializingBean,DisposableBean{
public Pig() {
System.out.println("实例化了Pig！！！");
}
public void eat() {
System.out.println("这是一只猪，猪吃饲料~");
}
@Override
public void afterPropertiesSet() throws Exception {
//在这里编写你的初始化工作的代码
System.out.println("......初始化代码.");
}
@Override
public void destroy() throws Exception {
//在bean被摧毁前，如果要执行一些任务，在此方法中编写代码
System.out.println("~~~~~~我要die了，在这里做点释放资源的操作");
}
}b. bean配置文件中的自定义init（）和destroy（）方法
1. 局部定义
可通过bean标记的init-method属性指定初始化时要调用的方法
可通过bean标记的destroy-method属性指定bean被摧毁前要调用的方法
<bean class="com.qdu.bean.Dog"
init-method="init" destroy-method="dispose" />在class中声明的Dog类中实现自定义init()和destory()方法：
public class Dog {
//方法名自定义，但是方法不能有参数
//自定义的一个方法init，用于包含初始化工作代码
public void init() {
System.out.println("调用了Dog类中的init......");
}
//方法名自定义，但是方法不能有参数
//自定义的一个方法dipsose，用于包含bean摧毁前要执行的工作代码
public void dispose() {
System.out.println("调用了Dog类中的dispose......");
}
public Dog() {
System.out.println("实例化了Dog！！！");
}
public void eat() {
System.out.println("这是一只狗，狗吃骨头！");
}
}
2. 全局定义
可全局配置初始化方法和摧毁bean之前要调用的方法。
可通过配置<beans>这个根元素的default-init-method来设置全局的初始化方法。
可通过配置<beans>这个根元素的default-destory-method来设置全局的初始化方法
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd"
default-init-method="init"
default-destroy-method="dispose">
<bean class="com.qdu.bean.Dog" />
</beans>考虑到代码重复利用，可以考虑保持各个类的初始化方法和摧毁前要调用的方法同名
c. @PostConstruct 和 @PreDestroy注解
使用@PostConstruct注解和@PreDestroy注解修饰自定义的init和destroy方法。
如果希望一个方法在bean初始化的时候被调用，执行初始化工作，则使用@PostConstruct注解修饰该方法：
@PostConstruct
public void init() {
System.out.println("调用了Sheep类中的init......");
}如果希望一个方法在bean被摧毁之前被调用，执行释放资源等工作，则使用@PreDestroy注解修饰该方法：
@PreDestroy
public void cleanUp() {
System.out.println("调用了Sheep类中的cleanUp......");
}d. 用于注入特定依赖的Aware接口
有时候可能需要获取某个特定的依赖，如想获取bean所在的上下文容器，则可以实现对应的Aware接口，并实现对应的方法
spring提供一些xxxAware接口，用于注入需要的一些依赖，例如，用于获取bean所属的上下文容器。如果希望在一个bean中获取bean所属的上下文容器，可以让bean实ApplicationContextAware
public class Mouse implements ApplicationContextAware{
//使用一个引用变量，用于引用所属的容器对象
private ApplicationContext ctx;
public Mouse() {
System.out.println("实例化Mouse！！！");
}
public void eat() {
System.out.println("这是一只Mouse，老鼠吃大米！！！");
Cat cat=ctx.getBean(Cat.class);
cat.eat();
}
//该方法将bean所属的容器对象传入该类，使用一个变量接收，然后就可以使用上下文容器了
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
ctx=applicationContext;
}
}2 DI-依赖注入
DI（Dependency Injection）- 依赖注入是IoC思想的一种实现方式，就是将 依赖对象的创建和维护转移到 被依赖对象类的外部 来实现。
也就是说：一个对象是被动接受依赖对象而不是自己主动去找，换句话说就是对象自己不需要负责寻找或创建它所依赖的对象。
而是由容器（container）来维护对象之间的依赖关系，并根据依赖关系将需要的对象注入。
如果对象A中使用了对象B，则对象A依赖对象B，不直接在A中new一个B对象，而是交给容器，让容器根据A和B的依赖关系，实例化B，并将B对象传递给A，这个过程就是依赖注入。
2.1 setter实现依赖注入
2.1.1 注入简单值(基本数据类型或字符串)
通过value指定要注入的值
<bean id="addr1" class="com.qdu.bean.Address">
<!-- property标记用于实现注入依赖 -->
<property name="province" value="山东" />
<property name="city" value="青岛" />
<property name="detailedAddress" value="宁夏路308号 青岛大学" />
</bean>spring还提供一种简写形式 : p:属性名="属性值"
<bean id="addr3" class="com.qdu.bean.Address" p:province="四川"
p:city="成都" p:detailedAddress="小吃街" />在Address类中，必须要给对应的属性生成setter访问器，因为要使用setXXX()方法来注入/设置需要的值
public class Address {
private String province; //省
private String city; //市
private String detailedAddress; //详细地址
@Override
public String toString() {
return "地址::" + province + "省" + city + "市" + detailedAddress;
}
public void setProvince(String province) {
System.out.println("setProvince()方法被调用........");
this.province = province;
}
public void setCity(String city) {
this.city = city;
}
public void setDetailedAddress(String detailedAddress) {
this.detailedAddress = detailedAddress;
}
}
2.1.2 注入引用的其他bean(引用类型)
使用ref属性指定要注入的bean的id或name
<bean id="emp1" class="com.qdu.bean.Employee">
<!-- 如果注入简单值，使用value属性指定要注入的值 -->
<property name="empId" value="E001" />
<property name="empName" value="小强" />
<property name="empSalary" value="50000" />
<!-- 如果注入引用的其他bean，使用ref属性指定要注入的bean的id或name -->
<property name="address" ref="addr1" />
</bean>引用的其他bean使用p:属性名-ref="引用的bean的id或name"
<bean id="emp2" class="com.qdu.bean.Employee" p:empId="E002"
p:empName="小明" p:empSalary="60000" p:address-ref="addr2" />2.1.3 注入集合(Set、List、Map、Properties)
set标记用于注入set集合的值
<property name="branchNames">
<!-- set标记用于注入set集合的值 -->
<set>
<!-- 如果集合中是引用的其他bean，使用ref标记，通过bean指定引用的bean的id或name -->
<!-- <ref bean="id或name" /> -->
<!-- 如果集合中是简单值，使用value指定值即可 -->
<value>山东分公司</value>
<value>山西分公司</value>
<value>广东分公司</value>
<value>广西分公司</value>
<value>海南分公司</value>
</set>
</property>list标记用于注入list集合的值
<property name="partnerNames">
<list>
<!-- 如果集合中是引用的其他bean，使用ref标记，通过bean指定引用的bean的id或name -->
<!-- <ref bean="id或name" /> -->
<!-- 如果集合中是简单值，使用value指定值即可 -->
<value>Oracle</value>
<value>Microsoft</value>
<value>IBM</value>
<value>Google</value>
</list>
</property>
<property name="employeeList">
<list>
<!-- 如果集合中是引用的其他bean，使用ref标记，通过bean指定引用的bean的id或name -->
<ref bean="emp1" />
<ref bean="emp2" />
</list>
</property>map标记用于注入map集合的值
<property name="branchManagers">
<map>
<!-- entry用于指定一项数据的注入 -->
<!-- 如果键是简单值，则使用key指定其值，如果是引用的其他bean，使用key-ref指定bean的id或name -->
<!-- 如果值是简单值，则使用value指定其值，如果是引用的其他bean，使用value-ref指定bean的id或name -->
<entry key="山东分公司" value-ref="emp1" />
<entry key="山西分公司" value-ref="emp2" />
</map>
</property>注入Properties集合，可以使用props标记或value标记
<property name="extraInfo1">
<props>
<prop key="registeredCapital">1000000</prop>
<prop key="legalPerson">小胖</prop>
<prop key="type">Joint venture</prop>
</props>
</property>
<property name="extraInfo2">
<value>
registeredCapital=2000000
legalPerson=Allen
type=Joint venture
</value>
</property>2.2 构造函数实现依赖注入
2.2.1 注入简单值(基本数据类型或字符串)
constructor-arg标记用于实现以setter的方式注入依赖。
如果使用setter注入，constructor-arg标记的name属性是类中的属性名；
如果使用构造函数注入，constructor-arg标记的name属性指定的是构造函数的参数的名称。
使用构造函数注入，需要生成对应参数的构造函数
<bean id="addr1" class="com.qdu.bean.Address">
<constructor-arg name="pro" value="山东" />
<constructor-arg name="city" value="青岛" />
<constructor-arg name="detailedAddress" value="宁夏路308号 青岛大学" />
</bean>使用构造函数注入，也可不写参数名称，但是必须保证参数的顺序是对的。
可以使用参数索引（0表示第一个参数），这样参数顺序随便写。
但是如果不写参数名称，也不写参数索引，则参数顺序必须正确。
<bean id="addr2" class="com.qdu.bean.Address">
<constructor-arg index="0" value="山东" />
<constructor-arg index="1" value="济南" />
<constructor-arg index="2" value="泉城广场" />
</bean>spring还提供一种简写形式 : c:参数名="值"
<bean id="addr3" class="com.qdu.bean.Address" c:pro="四川"
c:city="成都" c:detailedAddress="小吃街" />在Address类中要实现构造函数：
public class Address {
private String province; //省
private String city; //市
private String detailedAddress; //详细地址
//如果使用property标记实现依赖注入，则必须要给对应的属性生成setter访问器
//因为使用setXXX()方法来注入/设置需要的值
@Override
public String toString() {
return "地址::" + province + "省" + city + "市" + detailedAddress;
}
public Address() {
super();
}
public Address(String pro, String city, String detailedAddress) {
System.out.println("调用了带3个参数的构造函数实现依赖注入！！！");
this.province = pro;
this.city = city;
this.detailedAddress = detailedAddress;
}
public void setProvince(String province) {
System.out.println("setProvince()方法被调用........");
this.province = province;
}
public void setCity(String city) {
this.city = city;
}
public void setDetailedAddress(String detailedAddress) {
this.detailedAddress = detailedAddress;
}
}2.2.2 注入引用的其他bean(引用类型)
使用ref属性指定要注入的bean的id或name
<bean id="emp1" class="com.qdu.bean.Employee">
<!-- 如果注入简单值，使用value属性指定要注入的值 -->
<constructor-arg name="empId" value="E001" />
<constructor-arg name="empName" value="小强" />
<constructor-arg name="empSalary" value="50000" />
<!-- 如果注入引用的其他bean，使用ref属性指定要注入的bean的id或name -->
<constructor-arg name="address" ref="addr1" />
</bean>如果使用c:参数名写法，则简单值使用c:参数名="参数值"
引用的其他bean使用c:参数名-ref="引用的bean的id或name"
<bean id="emp2" class="com.qdu.bean.Employee" c:empId="E002"
c:empName="小明" c:empSalary="60000" c:address-ref="addr2" />2.2.3 注入集合(Set、List、Map、Properties)
set标记用于注入set集合的值
<constructor-arg name="branchNames">
<set>
<!-- 如果集合中是引用的其他bean，使用ref标记，通过bean指定引用的bean的id或name -->
<!-- <ref bean="id或name" /> -->
<!-- 如果集合中是简单值，使用value指定值即可 -->
<value>山东分公司</value>
<value>山西分公司</value>
<value>广东分公司</value>
<value>广西分公司</value>
<value>海南分公司</value>
</set>
</constructor-arg>
list标记用于注入list集合的值
<constructor-arg name="partnerNames">
<list>
<!-- 如果集合中是引用的其他bean，使用ref标记，通过bean指定引用的bean的id或name -->
<!-- <ref bean="id或name" /> -->
<!-- 如果集合中是简单值，使用value指定值即可 -->
<value>Oracle</value>
<value>Microsoft</value>
<value>IBM</value>
<value>Google</value>
</list>
</constructor-arg>
<constructor-arg name="partnerNames">
<list>
<!-- 如果集合中是引用的其他bean，使用ref标记，通过bean指定引用的bean的id或name -->
<ref bean="emp1" />
<ref bean="emp2" />
</list>
</constructor-arg>map标记用于注入map集合的值
<constructor-arg name="branchManagers">
<map>
<!-- entry用于指定一项数据的注入 -->
<!-- 如果键是简单值，则使用key指定其值，如果是引用的其他bean，使用key-ref指定bean的id或name -->
<!-- 如果值是简单值，则使用value指定其值，如果是引用的其他bean，使用value-ref指定bean的id或name -->
<entry key="山东分公司" value-ref="emp1" />
<entry key="山西分公司" value-ref="emp2" />
</map>
</constructor-arg>注入Properties集合，可以使用props标记或value标记
<constructor-arg name="extraInfo1">
<props>
<prop key="registeredCapital">1000000</prop>
<prop key="legalPerson">小胖</prop>
<prop key="type">Joint venture</prop>
</props>
</constructor-arg>
<constructor-arg name="extraInfo2">
<value>
registeredCapital=2000000
legalPerson=Allen
type=Joint venture
</value>
</constructor-arg>2.3 自动装配
在应用程序对象之间创建和管理关联的过程叫做装配，这构成了DI的核心。以上两种方法为显示装配(显式声明Bean之间的依赖)，自动装配(autowiring)不显式声明Bean之间的依赖，让容器选择合适的依赖项注入。
2.3.1 byName
byName是按照名称自动装配，意思是要注入的属性的属性名和要注入的bean的id或name(别名)相同，即可实现按照名称自动装配。
<bean id="person" class="com.qdu.bean.Boy" autowire="byName">
<property name="name" value="小兰" />
<!-- 这里注释了代码，表示不使用显式装配(wire) -->
<!-- <property name="axe" ref="fuzi" /> -->
<!-- <property name="pet" ref="chongwu" /> -->
</bean>byName 通过匹配 bean 的 id是否跟 setter 对应，对应则自动装配。比如以上代码，bean的id为person；如果我的person类中有一个setName()，则能够自动装配。
public interface Person {
void kanChai();
}
public class Boy implements Person {
private String name;
private Axe axe;
private Pet pet;
public void setAxe(Axe axe) {
this.axe = axe;
}
public void setName(String name) {
this.name = name;
}
public void setPet(Pet pet) {
this.pet = pet;
}
@Override
public void kanChai() {
System.out.println("砍柴人："+name);
System.out.println("Boy砍柴，力气大！！！");
axe.cut();
pet.showSkill();
}
}当一个bean带有autowire byName的属性时：
- 将查找其类中所有的set方法名，例如setCat，获得将set去掉并且首字母小写的字符串，即cat。
- 去spring容器中寻找是否有此字符串名称id的对象。
- 如果有，就取出注入；如果没有，就报空指针异常
2.3.2 byType
byType是按照类型自动装配。如果要注入的属性的数据类型和容器中某个bean的类型匹配，则实现自动装配。
<bean id="person" class="com.qdu.bean.Girl" autowire="byType">
<property name="name" value="小明" />
<!-- 这里不使用显式装配 -->
<!-- <property name="axe" ref="fuzi" /> -->
<!-- <property name="pet" ref="chongwu" /> -->
</bean>自动装配跟 id 无关，在配置bean 时不写 id 都不会报错。
但是 byType 的自动装配存在一个很严重的问题，因为不是通过唯一的 id 来匹配，而是通过类型来匹配，所以容器中不能存在多个相同类型的 bean，否则会抛出NoUniqueBeanDefinitionException异常。
2.3.3 constructor
constructor表示使用对应的构造函数实现自动装配，所以需要生成对应的构造函数
<bean id="person" class="com.qdu.bean.Girl" autowire="constructor">
<property name="name" value="小明" />
</bean>public class Girl implements Person {
private String name;
private Axe axe;
private Pet pet;
@Override
public void kanChai() {
System.out.println("砍柴人："+name);
System.out.println("Girl砍柴，力气更大！！！");
pet.showSkill();
axe.cut();
}
public Girl() {
super();
}
//如果使用构造函数实现自动装配，需要生成对应的构造函数
//使用constructor实现自动装配，只要构造函数的数据类型对了即可，参数名无所谓
public Girl(Axe a, Pet p) {
super();
System.out.println("带2个参数的构造函数~~~");
this.axe = a;
this.pet = p;
}
public void setName(String name) {
this.name = name;
}
public void setAxe(Axe axe) {
this.axe = axe;
}
public void setPet(Pet pet) {
this.pet = pet;
}
}2.3.4 注解
除了使用bean标记注册类为spring管理的bean，也可直接开启包扫描：component-scan标记用于开启组件的包扫描，指定包名，多个包名用逗号隔开。
默认会扫描指定包下使用了@Component、@Controller、@Service、@Repository等注解修饰的类，将类注册为spring管理的bean。
<context:component-scan base-package="com.qdu.bean">
</context:component-scan>- 使用@Component等注解将一个类注册为spring管理的bean，则bean的名称默认为首字母小写的类名，也可自行指定bean的名称。
- 在字段前使用@Autowired注解，则使用反射实现注入。@Autowired注解按照类型进行装配，如果存在多个匹配类型，会报错。@Autowired可用于构造函数前、setter方法前、其他任何用于注入的方法前、字段前。
- @Resource注解也可用于实现依赖注入。如果没有指定名称或类型，它会先按照名称进行装配；如果没有匹配的bean则继续按照类型进行装配；如果指定了名称，则按照名称进行装配
；如果指定了类型，则按照类型进行装配。
@Component("person")
public class Girl implements Person {
private String name;
@Autowired
private Axe axe;
//@Resource(name="dog")
//@Resource
private Pet pet;
@Autowired
public Girl(Axe axe) {
System.out.println("用于注入axe属性的构造函数~~~");
this.axe=axe;
}
@Autowired
public void setPet(Pet pet) {
System.out.println("用于注入pet属性的setter方法~~~");
this.pet=pet;
}
@Override
public void kanChai() {
System.out.println("砍柴人："+name);
System.out.println("Girl砍柴，力气更大！！！");
axe.cut();
pet.showSkill();
}
}如果使用@Autowired，那么是按照类型进行自动装配；如果存在多个匹配类型，会抛出异常 可使用@Qualifier注解进一步限定要注入的bean，这个注解不能在构造函数前面使用
@Component
public class Girl implements Person {
private String name;
private Axe axe;
@Autowired
@Qualifier("pig")
private Pet pet;
public Girl() {
}
public Girl(Pet pet) {
System.out.println("调用构造函数注入pet属性..................");
this.pet = pet;
}
//qualifier 限定符
@Autowired
@Qualifier("steelAxe")
//@Required //表示该属性必须要注入，在spring5.1开始，已经废除，不用关注了，直接使用构造函数注入替代即可
public void setAxe(Axe axe) {
System.out.println("调用setAxe()注入axe属性..................");
this.axe = axe;
}
public void setName(String name) {
this.name = name;
}
public void setPet(Pet pet) {
this.pet = pet;
}
@Override
public void kanChai() {
System.out.println("Girl砍柴，力气更大！！！");
axe.cut();
pet.showSkill();
}
}上述代码中，我们使用 @Qualifier 注解，并指定一个唯一的值，选择我们要注入的bean
如pet我们选择注入Pig类，Pig类上@Component并未指定bean的名称，故使用默认名称。
3 bean的继承
在使用bean标记注册一个bean为spring管理的bean时，可使用parent属性指定继承的bean的id或name，这样一个bean会继承另一个bean的配置和依赖注入（如init-method）。
如果又单独针对某个属性指定了依赖注入，会覆盖继承的依赖注入。
<bean id="emp1" class="com.qdu.bean.Employee"
init-method="init" destroy-method="destroy">
<property name="empId" value="E001" />
<property name="empName" value="小明" />
<property name="empSalary" value="20000.3" />
<property name="address" ref="addr1" />
</bean>
<bean id="emp2" class="com.qdu.bean.Employee" parent="emp1">
<property name="address" ref="addr2" />
</bean>4 使用工厂方法
默认情况下，spring容器调用无参构造函数创建bean实例。如果希望调用指定方法创建交给spring容器管理的bean实例，可通过bean标记的factory-method属性指定工厂方法的名称。
- 如果工厂方法是静态方法，则使用bean标记的class属性指定的是工厂类的全限定名称
- 如果工厂方法是非静态方法，则使用bean标记的factory-bean指定工厂对象bean的id或name
- 如果工厂方法带有参数，可使用constructor-arg标记指定传入的参数的信息
4.1 使用静态工厂方法返回自身实例
如果想通过一个工厂类的静态工厂方法创建bean，可通过factory-method属性指定创建实例的方法的名称。class指定工厂类的类型，也就是工厂类的全限定名称。
<bean class="com.qdu.bean.A" factory-method="getA" />A类的代码：
public class A {
//即使构造函数是私有的，spring也能通过反射访问该构造函数，实现实例化
private A() {
System.out.println("A的私有构造函数！！！");
}
//有的时候，我们不希望直接简单调用构造函数创建一个对象
//有的时候，我们希望spring通过调用我们指定的方法来获取bean的对象
public static A getA() {
System.out.println("调用了A类的静态工厂方法返回A的实例！！！");
return new A();
}
public void methodOfA() {
System.out.println("调用了A类的方法MethodOfA.............");
}
}4.2 使用静态工厂方法返回其他类实例
假设有一个Animal接口，在此基础上我们实现了dog、pig、sheep类，我们要调用Animal的静态方法来获取dog的实例。
<bean id="animal" class="com.qdu.bean.AnimalFactory"
factory-method="getAnimal1" />其中，class指定的应该是工厂方法所在的类的名称，factory-method属性指定创建实例的方法的名称。 实际创建的对象不是AnimalFactory类型，而是dog类型
AnimalFactory类：
public class AnimalFactory {
public static Animal getAnimal1() {
System.out.println("调用AnimalFactory类的静态工厂方法getAnimal1().................");
return new Dog();
}
}4.3 使用非静态工厂方法返回其他类实例
接上例，这次我们希望在工厂类AnimalFactory中用非静态方法实例化一个pig类
首先我们要在XML配置文件中注册AnimalFactory
<bean id="animalFactory" class="com.qdu.bean.AnimalFactory" />如果希望通过工厂类A的非静态方法来实例化B ，这时候不再使用class属性来指定生成的bean的类型。
factory-bean属性指定创建bean实例（如这里的Pig）的工厂对象是哪个，指定其id或name。
factory-method属性指定创建bean实例的工厂方法的名称。
id为animal的bean实际是一个Pig实例，也即是getAnimal2()方法返回的实例
<bean id="animal" factory-bean="animalFactory" factory-method="getAnimal2" />AnimalFactory类：
public class AnimalFactory {
public Animal getAnimal2() {
System.out.println("调用AnimalFactory类的实例工厂方法getAnimal2().................");
return new Pig();
}
}4.4 使用带参数的工厂方法
接上例，我们希望通过AnimalFactory这个工厂类的一个带参数的静态方法getAnimal3(int type)来创建spring管理的实例。
<bean id="animal" class="com.qdu.bean.AnimalFactory" factory-method="getAnimal3">
<constructor-arg name="type" value="2" />
</bean>constructor-arg在构造函数注入的时候是构造函数参数的名称，但是对于工厂方法，就是指定一个普通方法参数的信息(如这里传入的参数是type，传入的值为2)
AnimalFactory类：
public class AnimalFactory {
private static Map<Integer,Animal> map;
static {
map=new HashMap<>();
map.put(1,new Dog());
map.put(2,new Pig());
map.put(3,new Sheep());
}
public static Animal getAnimal3(int type) {
System.out.println("调用AnimalFactory类的静态工厂方法getAnimal3().................");
return map.get(type);
}
}
