[Java知识库]Spring实例化Bean的四种方式、Bean的作用域，生命周期

（4）Spring中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"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 该 BeanPostProcessor 将自动起作用，对标注 @Autowired 的 Bean 进行自动注入 -->
    <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>

    <!-- bean: spring工厂创建的一个对象(反射机制)
	id/name:对象的名字,可以用来引用或者获取对象, 一般为类名或接口名称的首字母小写
	class:要创建的对象类型的类字符串,类名全路径
 -->
    <bean id="userDao3" class="cn.itcast.spring.UserDaoImpl"/>

    <bean id="userDao4" class="cn.itcast.spring.UserDaoImpl"/>

    <bean id="userService" class="cn.itcast.spring.UserServiceImpl">
        <!-- 注入对象 -->
        <!-- property 根据类中的setter方法进行属性注入 -->
        <!-- name:setter方法的后缀小写,比如setXxx 对应的name为xxx -->
        <!-- ref:引用哪一个bean(对象),值为bean的id/name -->
        <!--用了Autowired就删掉Property,ref，否则报错-->
        <!-- <property name="userDao4" ref="userDao4" />-->
    </bean>

    <!-- 实例化 bean的四种方式 -->
    <!-- 1.默认构造器实例化对象 -->
    <bean id="bean1" class="cn.itcast.spring.bean.Bean1"/>

    <!-- 2.静态工厂获取实例化对象 -->
    <!-- class:直接指定到静态工厂类, factory-method: 指定生产实例的方法, spring容器在实例化工厂类的时候会自动调用该方法并返回实例对象 -->
    <bean id = "bean2" class="cn.itcast.spring.bean.Bean2Factory" factory-method="getBean2"/>

    <!-- 3：实例工厂的方式实例化bean -->
    <bean id="bean3Factory" class="cn.itcast.spring.bean.Bean3Factory"/>
    <!-- factory-bean相当于ref：引用一个bean对象 -->
    <bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3"/>

    <!--方式四:FactoryBean-->
    <!--spring在实例化对象的时候回判断是否该对象实现了FactoryBean接口,如果实现了就直接调用getObject()方法,并返回执行结果-->
    <bean id="bean4" class="cn.itcast.spring.bean.Bean4Factory"/>

    <!--
		bean的作用范围
		scope:配置作用范围的，默认值就是singleton单例
	 -->
    <!-- 单例 -->
    <!-- <bean id="singletonBean" class="cn.itcast.spring.c_xmlscope.SingletonBean" scope="singleton"/> -->
    <bean id="singletonBean" class="cn.itcast.spring.SingletonBean"/>
    <!-- 多例 -->
    <bean id="prototypeBean" class="cn.itcast.spring.PrototypeBean" scope="prototype"/>


</beans>

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>spring1</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.4</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

    </dependencies>


</project>

四种方式：
第一种：最常用
第二、第三种：一些框架初始化的时候用的多。
第四种:spring底层实现的比较多

SpringTest.java

package cn.itcast.spring;

import cn.itcast.spring.bean.Bean1;
import cn.itcast.spring.bean.Bean2;
import cn.itcast.spring.bean.Bean3;
import cn.itcast.spring.bean.Bean4;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void test() {
        //创建spring工厂
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //1.默认构造器获取bean对象
        Bean1 bean1 = (Bean1) ac.getBean("bean1");
        System.out.println("bean1 = " + bean1);

        //先构建实例化获取spring的容器（工厂、上下文）
        ApplicationContext ac2 = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.静态工厂
        Bean2 bean2 = (Bean2) ac2.getBean("bean2");
        System.out.println("bean2 = " + bean2);

        //先构建实例化获取spring的容器（工厂、上下文）
        ApplicationContext ac3 = new ClassPathXmlApplicationContext("applicationContext.xml");
        //3.实例工厂
        Bean3 bean3=(Bean3) ac3.getBean("bean3");
        System.out.println("bean3 = " + bean3);

        //先构建实例化获取spring的容器（工厂、上下文）
        ApplicationContext ac4 = new ClassPathXmlApplicationContext("applicationContext.xml");
        //4.FactoryBean
        Bean4 bean4=(Bean4) ac4.getBean("bean4");
        System.out.println("bean4 = " + bean4);

    }
}

Bean的作用域

项目开发中通常会使用：singleton 单例、 prototype多例
Singleton： 在一个spring容器中，对象只有一个实例。（默认值）
Prototype： 在一个spring容器中，存在多个实例，每次getBean 返回一个新的实例。

【注意】
单例是默认值，如果需要单例对象，则不需要配置scope。

SpringBeanTest.java

package cn.itcast.spring;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringBeanTest {
    @Test
    public void test() {
        //先构建实例化获取spring的容器（工厂、上下文）
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //目标1：看看多次获取bean的时候，是不是同一个
        //目标2：看看bean什么时候初始化的
        //获取单例的bean：应该是同一个
        //单例：每次从spring容器中获取的对象，是同一个对象
        //单例初始化：是在spring容器初始化的时候，就初始化了
        SingletonBean singletonBean1 = (SingletonBean) applicationContext.getBean("singletonBean");
        SingletonBean singletonBean2 = (SingletonBean) applicationContext.getBean("singletonBean");
        System.out.println("singletonBean1 = " + singletonBean1);
        System.out.println("singletonBean2 = " + singletonBean2);
        
        //获取多例的bean：
        //多例：每次从spring容器中获取的对象，不是同一个对象
        //多例初始化：是在getBean的时候初始化，相当于每次getbean就是在new Bean（）
        PrototypeBean prototypeBean1 = (PrototypeBean) applicationContext.getBean("prototypeBean");
        PrototypeBean prototypeBean2 = (PrototypeBean) applicationContext.getBean("prototypeBean");
        System.out.println("prototypeBean1 = " + prototypeBean1);
        System.out.println("prototypeBean2 = " + prototypeBean2);

    }
}

Bean的生命周期

通过spring工厂，可以控制bean的生命周期。
在xml配置Bean的初始化和销毁方法

通过 init-method属性 指定实例化后的调用方法
通过 destroy-method属性 指定销毁对象前的方法

LifeCycleBean.java

package cn.itcast.spring;

public class LifeCycleBean {
    //定义构造方法
    public LifeCycleBean() {
        System.out.println("LifeCycleBean构造器调用了");
    }

    //初始化后自动调用方法：方法名随意，但也不能太随便，一会要配置
    public void init(){
        System.out.println("LifeCycleBean-init初始化时调用");
    }

    //bean销毁时调用的方法
    public void destroy(){
        System.out.println("LifeCycleBean-destroy销毁时调用");
    }

}

applicationContext.xml

<!-- 生命周期调用的两个方法
	init-method:初始化时（后）调用的，bean中的共有方法即可
	destroy-method:销毁时（前）被调用的。
	-->
    <bean id="lifeCycleBean" class="cn.itcast.spring.LifeCycleBean" init-method="init" destroy-method="destroy" />

SpringBeanLife.java

package cn.itcast.spring;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringBeanLife {

    @Test
    public void test(){
        //先获取spring的容器，工厂，上下文
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //对于单例此时已经被初始化
        //获取bean
        LifeCycleBean lifeCycleBean=(LifeCycleBean) applicationContext.getBean("lifeCycleBean");

        System.out.println("lifeCycleBean = " + lifeCycleBean);
        //为什么没有销毁方法调用。
        //原因是：使用debug模式jvm直接就关了，spring容器还没有来得及销毁对象。
        //解决：手动关闭销毁spring容器，自动销毁单例的对象
       ((ClassPathXmlApplicationContext) applicationContext).close();

    }

}