@Component
public class UserComponent {
    @Bean
    public User getUser() {
        User user = new User();
        user.setId(1);
        user.setName("張三");
        user.setPassWord("111111");
        return user;
    }
}

步驟二：使用者A獲取到公共 Bean，進行修改

@Controller
public class UserControllerA {
    @Autowired
    private User user;
    public User getUser1() {
        System.out.println("使用者A拿到的原始user：" + user);
        User myUser = user;
        myUser.setName("李四");
        return myUser;
    }
}

步驟三：使用者B直接將獲取到的公共的 Bean 進行返回

@Controller
public class UserControllerB {
    @Autowired
    private User user;
    public User getUser2() {
        return user;
    }
}

步驟四：main 中獲取 UserControllerA 類和 UserControllerB 類使用查看

public class Start {
    public static void main(String[] args) {
        //獲取 Spring 上下文
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        //獲取到Spring容器中的 UserControllerA 類（Bean 對象）
        UserControllerA userControllerA = context.getBean("userControllerA",UserControllerA.class);
        //使用 Bean 對象
        System.out.println("使用者A->"+userControllerA.getUser1());
		//獲取到Spring容器中的 UserControllerA 類（Bean 對象）
        UserControllerB userControllerB = context.getBean("userControllerB",UserControllerB.class);
        //使用 Bean 對象
        System.out.println("使用者B->"+userControllerB.getUser2());
    }
}

預期結(jié)果：

使用者 A修改后，其結(jié)果是修改過的；使用者 B 沒有修改過，其結(jié)果應該和原始user一樣

結(jié)果顯示：

和預期結(jié)果有所不同，使用者 A 和使用者 B 所得到的結(jié)果都是被修改過的。

這是因為在 Spring 中，Bean 默認情況下是單例狀態(tài)，大家用的都是同一份對象，是全局共享的，當有其他人修改了該對象，另一個人所獲取到的對象就是被修改過的，這便是 Bean 六大作用域之一——單例作用域（singleton）

在寫 WEB 項目的時候，我們知道 DataSource 就是單例模式，使用單例，好處多多，可以確保所有對象都訪問唯一實例，而且減少了內(nèi)存的開支和系統(tǒng)性能的開銷，因此 Bean 默認情況下是單例狀態(tài)。

若想要按照預期結(jié)果輸出，就需要將 Bean 的作用域設置成原型作用域，即無論誰來使用 Bean 對象，獲取到的都是原始的 Bean 對象，大家各玩各的。

需要在注入的對象上使用注解修改作用域，有以下兩種方法（Scope就是作用域的意思）

直接將作用域以 String 類型寫到（）中
使用全局參數(shù)，類似于枚舉

@Component
public class UserComponent {
    //@Scope("prototype")    //方法一
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) //方法二
    @Bean
    public User getUser() {
        User user = new User();
        user.setId(1);
        user.setName("張三");
        user.setPassWord("111111");
        return user;
    }
}

Bean 的 6 種作用域

singleton：單例作用域

Bean 在 IoC 容器中只存在一個實例
當 Bean 對象屬性狀態(tài)無需更新時使用該作用域
Spring 支持

prototype：原型作?域/多例作?域

每次獲取該 Bean 時都會創(chuàng)建新的實例，即獲取的都是原始的 Bean
當 Bean 對象屬性狀態(tài)會更新時使用該作用域
Spring 支持

request：請求作用域

每次 HTTP 請求都會創(chuàng)建新的 Bean 實例
一次 HTTP 請求和響應共享的 Bean
限定 SpringMVC

session：會話作用域

在一個 HTTP session中，創(chuàng)建一個 Bean 實例
用戶會話共享一個 Bean
限定 SpringMVC

application：全局作用域

在一個 HTTP Servlet Context中，創(chuàng)建一個 Bean 實例
一個 WEB 上下文中共享一個 Bean
限定 SpringMVC

websocket： HTTP WebSocket 作?域（不常用）

在一個 HTTP WebSocket 中，創(chuàng)建一個 Bean 實例
限定 Spring WebSocket

單例作用域和全局作用域比較像，但全局作用域范圍沒有單例作用域大，前者是 Spring 核心的作用域，后者是 Spring Web 中的作用域，前者作用于 IoC 容器，后者作用于 Servlet 容器

二、Spring 的執(zhí)行流程

Spring 的執(zhí)行流程也可以說是 Bean的執(zhí)行流程，主要分成4部分

啟動 Spring 容器
加載 XML 文件，實例化 Bean（進行內(nèi)存的分配）
Bean 存到 Spring 容器中（五大類注解，方法注解）
將存儲的 Bean 中的注入的對象屬性進行初始化，即進行裝配（取出 Bean）

三、Bean 的生命周期

Bean 的生命周期即 Bean 從誕生到銷毀的整個過程

實例化 Bean 對象，申請內(nèi)存空間

設置 Bean 的屬性，進行依賴注入和裝配

Bean 的初始化

各種 Aware 感知：BeanNameAware、BeanFactoryAware、ApplicationContextAware、…
執(zhí)? BeanPostProcessor 初始化前置?法
初始化方法：構造器方法 @PostConstructor （對象加載完依賴注入后執(zhí)行）
初始化方法：init-method
執(zhí)? BeanPostProcessor 初始化后置?法

使用 Bean

銷毀 Bean

銷毀方法：@PreDestroy
接口方法：DisposableBean
銷毀方法：destroy-method

補充

實例化和初始化的區(qū)別

實例化：這里的實例化和從前的實例化對象是有區(qū)別的，這里的實例化就負責內(nèi)存的分配，一個從無到有的過程。實例化和屬性設置時 Java 級別的系統(tǒng)“事件”，操作過程是不可人工干預的
初始化：是對 Bean 進行填充的過程，程序員可以進行介入，真正的將 Bean 放到 Spring 容器中

@PostConstructor 和 @PreDestroy 是注解方式進行初始化和注銷，init-method 和 destroy-method 是 XML 方法進行初始化和注銷，一般只要使用其中的一種進行初始化

設置屬性一定要在初始化之前，因為初始化也可能需要使用到注入的對象，如果沒有進行屬性的設置，初始化就會出現(xiàn)問題

案例：生命周期演示

@Component
public class BeanLife implements BeanNameAware {
    @Override
    public void setBeanName(String s) {
        System.out.println("BeanName 感知："+ s);
    }
    @PostConstruct
    public void postConstructor() {
        System.out.println("執(zhí)行初始化方法：PostConstructor");
    }
    @PreDestroy
    public void preDestroy() {
        System.out.println("執(zhí)行銷毀方法：PreDestroy");
    }
    public void initMethod() {
        System.out.println("執(zhí)行初始化方法：init-method");
    }
    public void destroyMethod() {
        System.out.println("執(zhí)行銷毀方法：destroy-method");
    }
}

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"
       xmlns:content="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置一下：bean注解掃描的根路徑（方面后面更簡單存儲對象到spring容器）-->
    <content:component-scan base-package="com.bit.beans"></content:component-scan>
    <beans>
        <bean id="beanLife" class="com.bit.beans.Component.BeanLife" init-method="initMethod"
        destroy-method="destroyMethod"></bean>
    </beans>
</beans>

調(diào)用

public class Start {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new
                ClassPathXmlApplicationContext("spring.xml");
        BeanLife beanLife = context.getBean("beanLife",BeanLife.class);
        System.out.println("---使用 Bean 對象---");
        System.out.println("---注銷 Bean 對象--- ");
        context.destroy();//容器的銷毀相當于銷毀所有的 Bean
    }
}

結(jié)果顯示：