【Spring】Spring中的Bean - 2、Baen的实例化 (构造器、静态工厂、实例工厂)
Bean的实例化
简单记录-Java EE企业级应用开发教程（Spring+Spring MVC+MyBatis）-Spring中的Bean
Bean的实例化有哪些方式？
在面向对象的程序中，想要使用某个对象，就需要先实例化这个对象。同样，在Spring中，要想使用容器中的Bean，也需要实例化Bean。实例化Bean有三种方式，
分别为构造器实例化、静态工厂方式实例化和实例工厂方式实例化（其中最常用的是构造器实例化）。
构造器实例化
构造器实例化是指Spring容器通过Bean对应类中默认的无参构造方法来实例化Bean。
下面通过一个案例来演示Spring容器是如何通过构造器来实例化Bean的。
（1）在Idea中，在JavaEE-enterprise-application-development-tutorial项目里，创建一个名为chapter02的Web项目module，
pom.xml
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.23.RELEASE</version>
</dependency>
会自动下载导入对应的依赖项。
（2）在chapter02模块的src/main/java目录下，创建一个com.awen.instance.constructor包，在该包中创建Bean1类， Bean1.java
package com.awen.instance.constructor;
public class Bean1 {
}
（3）在在src/main/resources目录下，创建Spring的配置文件beans1.xml，在配置文件中定义一个id为bean1的Bean，并通过class属性指定其对应的实现类为Bean1，beans1.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-4.3.xsd">
<bean id="bean1" class="com.awen.instance.constructor.Bean1" />
</beans>
<bean id="bean1" class="com.awen.instance.constructor.Bean1" />
（4）在com.awen.instance.constructor包中，创建测试类InstanceTest1，来测试构造器是否能实例化Bean，
InstanceTest1.java
package com.awen.instance.constructor;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.ClassPathXmlApplicationContext;
public class InstanceTest1 {
public static void main(String[] args) {
// ApplicationContext在加载配置文件时，对Bean进行实例化
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("beans1.xml");
Bean1 bean = (Bean1) applicationContext.getBean("bean1");
System.out.println(bean);
}
}
Resource注解无法导入依赖使用javax.annotation的注解类
Maven导入
<dependency>
<groupId>javax.annotation</groupId>
<artifactId>jsr250-api</artifactId>
<version>1.0</version>
</dependency>
在InstanceTest1.java文件中，Spring容器ApplicationContext会加载配置文件。
在加载时，Spring容器会通过id为bean1的实现类Bean1中默认的无参构造方法对Bean进行实例化。执行程序后，控制台的输出结果如图所示。
D:\Environments\jdk-11.0.2\bin\java.exe -javaagent:D:\Java\ideaIU-2019.2.win\lib\idea_rt.jar=13768:D:\Java\ideaIU-2019.2.win\bin -Dfile.encoding=UTF-8 -classpath D:\IdeaProjects\JavaEE-enterprise-application-development-tutorial\chapter02\target\classes;D:\Environments\apache-maven-3.6.2\maven-repo\javax\annotation\jsr250-api\1.0\jsr250-api-1.0.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-webmvc\5.2.3.RELEASE\spring-webmvc-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-aop\5.2.3.RELEASE\spring-aop-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-beans\5.2.3.RELEASE\spring-beans-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-context\5.2.3.RELEASE\spring-context-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-core\5.2.3.RELEASE\spring-core-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-jcl\5.2.3.RELEASE\spring-jcl-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-expression\5.2.3.RELEASE\spring-expression-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-web\5.2.3.RELEASE\spring-web-5.2.3.RELEASE.jar com.awen.instance.constructor.InstanceTest1
com.awen.instance.constructor.Bean1@7eac9008
Process finished with exit code 0
从运行结果可以看出，Spring容器已经成功实例化了Bean1，并输出了结果。
com.awen.instance.constructor.InstanceTest1
com.awen.instance.constructor.Bean1@7eac9008
构造器实例化是指Spring容器通过Bean对应类中默认的无参构造方法来实例化Bean。
静态工厂方式实例化
使用静态工厂是实例化Bean的另一种方式。
该方式要求开发者创建一个静态工厂的方法来创建Bean的实例，其Bean配置中的class属性所指定的不再是Bean实例的实现类，而是静态工厂类，同时还需要使用factory-method属性来指定所创建的静态工厂方法。下面通过一个案例来演示如何使用静态工厂方式实例化Bean。
（1）在chapter02模块的src/main/java目录下，创建一个com.awen.instance.static_factory包，在该包中创建一个Bean2类，该类与Bean1一样，不需添加任何方法。
package com.awen.instance.static_factory;
public class Bean2 {
}
（2）在com.awen.instance.static_factory包中，创建一个MyBean2Factory类，并在类中创建一个静态方法createBean()来返回Bean2实例，如文件所示。文件 MyBean2Factory.java
package com.awen.instance.static_factory;
public class MyBean2Factory {
//使用自己的工厂创建Bean2实例
public static Bean2 createBean(){
return new Bean2();
}
}
（3）在src/main/resources目录下，创建Spring配置文件beans2.xml，编辑后如文件所示。文件 beans2.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-4.3.xsd">
<bean id="bean2"
class="com.awen.instance.static_factory.MyBean2Factory"
factory-method="createBean" />
</beans>
<bean id="bean2" class="com.awen.instance.static_factory.MyBean2Factory" factory-method="createBean" />
在上述配置文件中，首先通过元素的id属性定义了一个名称为bean2的Bean，然后由于使用的是静态工厂方法，所以需要通过class属性指定其对应的工厂实现类为MyBean2Factory。由于这种方式配置Bean后，Spring容器不知道哪个是所需要的工厂方法，所以增加了factory-method属性来告诉Spring容器，其方法名称为createBean。
bean2是静态工厂类的工厂方法创建的
（4）在com.awen.instance.static_factory包中，创建一个测试类InstanceTest2，来测试使用静态工厂方式是否能实例化Bean，编辑后如文件所示。文件 InstanceTest2.java
package com.awen.instance.static_factory;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.ClassPathXmlApplicationContext;
public class InstanceTest2 {
public static void main(String[] args) {
// ApplicationContext在加载配置文件时，对Bean进行实例化
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("beans2.xml");
System.out.println(applicationContext.getBean("bean2"));
}
}
执行程序后，控制台的输出结果如图所示。
D:\Environments\jdk-11.0.2\bin\java.exe -javaagent:D:\Java\ideaIU-2019.2.win\lib\idea_rt.jar=13958:D:\Java\ideaIU-2019.2.win\bin -Dfile.encoding=UTF-8 -classpath D:\IdeaProjects\JavaEE-enterprise-application-development-tutorial\chapter02\target\classes;D:\Environments\apache-maven-3.6.2\maven-repo\javax\annotation\jsr250-api\1.0\jsr250-api-1.0.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-webmvc\5.2.3.RELEASE\spring-webmvc-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-aop\5.2.3.RELEASE\spring-aop-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-beans\5.2.3.RELEASE\spring-beans-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-context\5.2.3.RELEASE\spring-context-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-core\5.2.3.RELEASE\spring-core-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-jcl\5.2.3.RELEASE\spring-jcl-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-expression\5.2.3.RELEASE\spring-expression-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-web\5.2.3.RELEASE\spring-web-5.2.3.RELEASE.jar com.awen.instance.static_factory.InstanceTest2
com.awen.instance.static_factory.Bean2@40005471
Process finished with exit code 0
从运行结果可以看到，使用自定义的静态工厂方法，已成功实例化了Bean2。
com.awen.instance.static_factory.InstanceTest2
com.awen.instance.static_factory.Bean2@40005471
静态工厂方法实例化Bean，要求开发者创建一个静态工厂的方法来创建Bean的实例，其Bean配置中的class属性所指定的不再是Bean实例的实现类，而是静态工厂类，同时还需要使用factory-method属性来指定所创建的静态工厂方法。
<bean id="bean2" class="com.awen.instance.static_factory.MyBean2Factory" factory-method="createBean" />
实例工厂方式实例化
还有一种实例化Bean的方式就是采用实例工厂。此种方式的工厂类中，不再使用静态方法创建Bean实例，而是采用直接创建Bean实例的方式。同时，在配置文件中，需要实例化的Bean也不是通过class属性直接指向的实例化类，而是通过factory-bean属性指向配置的实例工厂，然后使用factory-method属性确定使用工厂中的哪个方法。下面通过一个案例来演示实例工厂方式的使用。
（1）在chapter02模块的src/main/java目录下，创建一个com.awen.instance.factory包，在该包中创建一个Bean3类，该类与Bean1一样，不需添加任何方法。
package com.awen.instance.factory;
public class Bean3 {
}
（2）在com.awen.instance…factory包中，创建一个MyBean3Factory类，在类中使用默认无参构造方法输出“bean3工厂实例化中”语句，并使用createBean()方法创建Bean3对象，如文件所示。MyBean3Factory.java
package com.awen.instance.factory;
public class MyBean3Factory {
public MyBean3Factory() {
System.out.println("bean3工厂实例化中");
}
//创建Bean3实例的方法
public Bean3 createBean(){
return new Bean3();
}
}
（3）在src/main/resources目录下，创建Spring配置文件beans3.xml，编辑后如文件所示。文件 beans3.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-4.3.xsd">
<!-- 配置工厂 -->
<bean id="myBean3Factory"
class="com.awen.instance.factory.MyBean3Factory" />
<!-- 使用factory-bean属性指向配置的实例工厂，
使用factory-method属性确定使用工厂中的哪个方法-->
<bean id="bean3" factory-bean="myBean3Factory"
factory-method="createBean" />
</beans>
<!-- 配置工厂 --> <bean id="myBean3Factory" class="com.awen.instance.factory.MyBean3Factory" /> <!-- 使用factory-bean属性指向配置的实例工厂， 使用factory-method属性确定使用工厂中的哪个方法--> <bean id="bean3" factory-bean="myBean3Factory" factory-method="createBean" />
在上述配置文件中，首先配置了一个工厂Bean，然后配置了需要实例化的Bean。在id为bean3的Bean中，使用factory-bean属性指向配置的实例工厂，该属性值就是工厂Bean的id。使用factory-method属性来确定使用工厂中的createBean()方法。
实例化了实例工厂
实例工厂工厂方法创建
（4）在com.awen.instance.factory的包中，创建测试类InstanceTest3，来测试实例工厂方式能否实例化Bean，编辑后如文件所示。文件 InstanceTest3.java
package com.awen.instance.factory;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.ClassPathXmlApplicationContext;
public class InstanceTest3 {
public static void main(String[] args) {
// ApplicationContext在加载配置文件时，对Bean进行实例化
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans3.xml");
System.out.println(applicationContext.getBean("bean3"));
}
}
执行程序后，控制台的输出结果如图所示。
D:\Environments\jdk-11.0.2\bin\java.exe -javaagent:D:\Java\ideaIU-2019.2.win\lib\idea_rt.jar=14114:D:\Java\ideaIU-2019.2.win\bin -Dfile.encoding=UTF-8 -classpath D:\IdeaProjects\JavaEE-enterprise-application-development-tutorial\chapter02\target\classes;D:\Environments\apache-maven-3.6.2\maven-repo\javax\annotation\jsr250-api\1.0\jsr250-api-1.0.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-webmvc\5.2.3.RELEASE\spring-webmvc-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-aop\5.2.3.RELEASE\spring-aop-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-beans\5.2.3.RELEASE\spring-beans-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-context\5.2.3.RELEASE\spring-context-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-core\5.2.3.RELEASE\spring-core-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-jcl\5.2.3.RELEASE\spring-jcl-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-expression\5.2.3.RELEASE\spring-expression-5.2.3.RELEASE.jar;D:\Environments\apache-maven-3.6.2\maven-repo\org\springframework\spring-web\5.2.3.RELEASE\spring-web-5.2.3.RELEASE.jar com.awen.instance.factory.InstanceTest3
bean3工厂实例化中
com.awen.instance.factory.Bean3@49438269
Process finished with exit code 0
从运行结果从可以看到，使用实例工厂的方式，同样成功实例化了Bean3
com.awen.instance.factory.InstanceTest3
bean3工厂实例化中
com.awen.instance.factory.Bean3@49438269
<!-- 配置工厂 --> <bean id="myBean3Factory" class="com.awen.instance.factory.MyBean3Factory" /> <!-- 使用factory-bean属性指向配置的实例工厂， 使用factory-method属性确定使用工厂中的哪个方法--> <bean id="bean3" factory-bean="myBean3Factory" factory-method="createBean" />
在上述配置文件中，首先配置了一个工厂Bean，然后配置了需要实例化的Bean。在id为bean3的Bean中，使用factory-bean属性指向配置的实例工厂，该属性值就是工厂Bean的id。使用factory-method属性来确定使用工厂中的createBean()方法。
采用实例工厂方法实例化Bean。此种方式的工厂类中，不再使用静态方法创建Bean实例，而是采用直接创建Bean实例的方式。同时，在配置文件中，需要实例化的Bean也不是通过class属性直接指向的实例化类，而是通过factory-bean属性指向配置的实例工厂，然后使用factory-method属性确定使用工厂中的哪个方法。
静态不用创建工厂，实例工厂需要。
