Bean的实例化

文章目录

• 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属性确定使用工厂中的哪个方法。

静态不用创建工厂，实例工厂需要。