Java框架之spring（一）Spring簡介與IOC

Spring簡介

單體地獄：Servlet JDBC JSP …

替代JDBC的框架： MyBatis；

Spring：春天—>給軟件行業帶來春天

2002，Rod johnson 首次推出了Spring框架的前身 interface21框架

2003，Spring框架以interface21框架爲基礎，重新設計，發佈1.0正式版。

Spring官網：https://spring.io/

Spring下載：https://spring.io/projects/spring-framework#learn

版本說明：

我們在下載軟件會遇到諸如release,stable,alpha,beta,pre,current,eval,rc,snapshot等版本，程序猿下載插件時尤爲常見，現在我說明以下版本的意思

1，snapshot(快照)，也即開發版，我們創建maven項目時，編輯器會自動給我們填入 1.0-SNAPSHOT版本，也就是1.0開發版，這個版本不能使用，因爲該版本處於開發的過程，所以運行時會不時地更新，導致功能變化，正式環境中不得使用snapshot版本的庫；

2，alpha，內部測試版，來源於字母α，是比較早的版本，主要是給開發人員和測試人員測試和找BUG用的，不建議使用；

3，beta，公開測試版，來源於字母β，這是比alpha進一步的版本，面向公衆測試，但是不建議使用

4，pre，這個和alpha版本類似，有時還會細分爲M1,M2版本，不建議使用；

5，RC(Release Candidate) 顧名思義麼 ! 用在軟件上就是候選版本。系統平臺上就是發行候選版本；

6，GA(General Availability)正式發佈的版本，在國外都是用GA來說明release版本的；

7，release，發行版，這是release的中文意思，也就是官方推薦使用的版本；

8，stable，穩定版，這個版本相比於測試版更加穩定，去除了測試版許多的bug，完善了一些功能，建議使用；

9，current，最新版，但是不一定是穩定版本，需要看一下是否還有release或者stable等版本；

10，eval，評估版。可能會有一個月或者固定時間的使用期限；

SpringGithub地址：https://github.com/spring-projects/spring-framework

Spring官網下載地址：https://repo.spring.io/release/org/springframework/spring/

Spirng優點

• Spring是開源，免費的。
• Spring是一個輕量級的框架，非入侵式的框架。
  • 沒有任何其他的依賴，使用他，不需要導入其他的包。
• IOC AOP
  • 控制反轉
  • 面向切面編程
• 對事務的支持
• 對框架的支持，不需要任何成本就可以引入其他框架。MyBatis、Hibernate，Strut1/2，SpringMVC
  • SSH、SSM

重要：一句話來概括：Spring是一個輕量級的控制反轉【IOC】和麪向切面【AOP】的（容器）框架。

OOP: 面向對象編程

Spring想做粘合劑。—> 發展出來一套自己的生態；

Spring組成

架構 : mvc三層架構

Spring 框架是一個分層架構，由 7 個定義良好的模塊組成。Spring 模塊構建在覈心容器之上，核心容器定義了創建、配置和管理 bean 的方式。

組成 Spring 框架的每個模塊（或組件）都可以單獨存在，或者與其他一個或多個模塊聯合實現。每個模塊的功能如下：

• 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要組件是 BeanFactory，它是工廠模式的實現。BeanFactory 使用控制反轉 （IOC） 模式將應用程序的配置和依賴性規範與實際的應用程序代碼分開。
• Spring 上下文：Spring 上下文是一個配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企業服務，例如 JNDI、EJB、電子郵件、國際化、校驗和調度功能。
• Spring AOP：通過配置管理特性，Spring AOP 模塊直接將面向方面的編程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何對象支持 AOP。Spring AOP 模塊爲基於 Spring 的應用程序中的對象提供了事務管理服務。通過使用 Spring AOP，不用依賴 EJB 組件，就可以將聲明性事務管理集成到應用程序中。
• Spring DAO：JDBC DAO 抽象層提供了有意義的異常層次結構，可用該結構來管理異常處理和不同數據庫供應商拋出的錯誤消息。異常層次結構簡化了錯誤處理，並且極大地降低了需要編寫的異常代碼數量（例如打開和關閉連接）。Spring DAO 的面向 JDBC 的異常遵從通用的 DAO 異常層次結構。
• Spring ORM：Spring 框架插入了若干個 ORM 框架，從而提供了 ORM 的對象關係工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有這些都遵從 Spring 的通用事務和 DAO 異常層次結構。
• Spring Web 模塊：Web 上下文模塊建立在應用程序上下文模塊之上，爲基於 Web 的應用程序提供了上下文。所以，Spring 框架支持與 Jakarta Struts 的集成。Web 模塊還簡化了處理多部分請求以及將請求參數綁定到域對象的工作。
• Spring MVC 框架：MVC 框架是一個全功能的構建 Web 應用程序的 MVC 實現。通過策略接口，MVC 框架變成爲高度可配置的，MVC 容納了大量視圖技術，其中包括 JSP、Velocity、Tiles、iText 和 POI。

Spring 框架的功能可以用在任何 J2EE 服務器中，大多數功能也適用於不受管理的環境。Spring 的核心要點是：支持不綁定到特定 J2EE 服務的可重用業務和數據訪問對象。毫無疑問，這樣的對象可以在不同 J2EE 環境 （Web 或 EJB）、獨立應用程序、測試環境之間重用。

Spring的組件：

SpringBoot 和 Spring Cloud

Spring Boot ：一款可以快速構建Spring應用的腳手架； 約定大於配置 ， 承上啓下。

Spring Cloud：基於SpringBoot實現的；他是一個生態圈；

IOC推導

◆目的：解決企業應用開發的複雜性

◆功能：使用基本的JavaBean代替EJB，並提供了更多的企業應用功能

◆範圍：任何Java應用

Spring是一個輕量級控制反轉(IoC)和麪向切面(AOP)的容器框架。

分析實現

我們使用原來的方式寫一段代碼測試：dao–service—前端

思考：現在前端傳遞或者調用不會變，所有操作都是我們程序猿來實現；

解決方案：前端操作，後臺不變；留一個調用的接口

IOC的原型。

IOC的本質

控制反轉 （inversion of Control）：IOC

他是一種設計思想。 根據這個思想有實現的方式，DI ： 依賴注入。

本質就是設置接口 ， set方法，是一種抽象思維

反轉： 從被動到主動 ， 程序猿主動控制 到 被動接受 ， 由編寫代碼，編寫接口，程序具有高度配置性和動態性；

讓程序的耦合性大大降低。方便模塊獨立：----> 微服務。解耦 。

HelloSpring

1.導入jar包

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>4.3.9.RELEASE</version>
</dependency>

2.創建實體類

package com.kuang.pojo;

public class Hello {

    private String name;

    public Hello() {
    }

    public Hello(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void show(){
        System.out.println("Hello,"+name);
    }

    @Override
    public String toString() {
        return "Hello{" +
                "name='" + name + '\'' +
                '}';
    }
}

3.編寫Spring的配置文件

beans.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">

    <!--bean就是一個java對象，由Spring管理和創建-->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>

    <!--bean就是一個java對象，由Spring管理和創建-->
    <bean id="hello2" class="com.kuang.pojo.Hello">
        <property name="name" value="WestOS"/>
    </bean>

    <!--// Hello hello2 = new Hello();-->
    <!--// hello2.setName (WestOS)-->

</beans>

4.測試類

package com.kuang.pojo;

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

public class HelloTest {
    @Test
    public void test(){

        //解析beans.xml配置文件,生產管理相應的Bean對象;
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        //通過Bean得到這個對象的實體
        Hello hello = (Hello)context.getBean("hello2");

        hello.show();

    }
}

思考問題？

• Hello對象是由誰創建的？
  • hello對象是由Spring創建的。
  • beans.xml ----> 管理bean，Java對象 ， Spring就像一個容器，存放了許多的對象；
    • 解析配置文件
    • 通過反射創建對象並且設置值
• Hello對象的屬性是怎麼設置值的？
  • hello對象的屬性是由Spring容器創建的。

這個過程就叫控制反轉：IOC

控制：誰來控制對象的創建？ 原來 ：程序猿來控制， 使用Spring後，Spring來創建對象的

反轉：程序本身不創建對象了，變成被動接受對象。

依賴注入：DI ，本質就是利用set方式來注入的。

IOC是一種編程思想。由主動的編程到被動的接受；

修改測試Demo

使用spring完成之前 Oracle 和 Mysql 獲取用戶信息的小Demo；

項目結構：

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>com.kuang</groupId>
    <artifactId>spring-study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>Spring01</module>
        <module>Spring02</module>
        <module>Spring03</module>
        <module>Spring04</module>
        <module>Spring05</module>
        <module>Spring06</module>
        <module>Spring07</module>
    </modules>


    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.9.RELEASE</version>
        </dependency>

    </dependencies>


</project>

pojo實體類：

package com.kuang.pojo;

public class Hello {

    private String name;

    public Hello() {
    }

    public Hello(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void show(){
        System.out.println("Hello,"+name);
    }

    @Override
    public String toString() {
        return "Hello{" +
                "name='" + name + '\'' +
                '}';
    }
}

resources資源包配置：
beans.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">

    <!--bean就是一個java對象，由Spring管理和創建-->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>

    <!--bean就是一個java對象，由Spring管理和創建-->
    <bean id="hello2" class="com.kuang.pojo.Hello">
        <property name="name" value="WestOS"/>
    </bean>

    <!--// Hello hello2 = new Hello();-->
    <!--// hello2.setName (WestOS)-->

</beans>

Test測試類：

package com.kuang.pojo;

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

public class HelloTest {
    @Test
    public void test(){

        //解析beans.xml配置文件,生產管理相應的Bean對象;
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        //通過Bean得到這個對象的實體
        Hello hello = (Hello)context.getBean("hello2");

        hello.show();

    }
}

測試結果:

如果把測試類中hello2改爲hello則輸出結果爲：對應得爲bean.xml文件value值；

OK , 到了現在 , 我們徹底不用再程序中去改動了 , 要實現不同的操作 , 只需要在xml配置文件中進行修改 , 所謂的IoC,一句話搞定 : 對象由Spring 來創建 , 管理 , 裝配 !

IOC創建對象的方式

我們平時創建對象的方式：

有參構造 、無參構造

我們來看看在Spring中怎麼處理這兩種情況

項目建立：

項目結構：

** 創建實體類**
User:

package com.kuang.pojo;

public class User {

    private String name;
    private String sex;
    private int age;

    public User() {
        System.out.println("User的無參構造");
    }

    public User(String name) {
        System.out.println("User的有參構造");
        this.name = name;
    }

    public User(String name, int age) {
        System.out.println("User的有參構造2");
        this.name = name;
        this.age = age;
    }

    public User(String name, String sex, int age) {
        System.out.println("User的有參構造3");
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public void setName(String name) {
        System.out.println(name+":"+System.currentTimeMillis());
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Spring配置文件

beans.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<!--suppress SpringFacetInspection -->
<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">

    <!--
    Spring的配置文件
    bean 代表一個對象
    alias  別名
    import  導入一個其他資源
    -->
    <bean id="user" class="com.kuang.pojo.User">
        <property name="name" value="qinjiang"/>
    </bean>

    <!--使用構造器的參數下標進行賦值-->
    <bean id="user2" class="com.kuang.pojo.User">
        <constructor-arg index="0" value="kuangshen"/>
        <constructor-arg index="1" value="18"/>
    </bean>

    <!--通過名字進行賦值-->
    <bean id="user3" class="com.kuang.pojo.User">
        <constructor-arg name="name" value="kuangshen3"/>
        <constructor-arg name="age" value="3"/>
    </bean>

    <!--通過類型進行賦值-->
    <bean id="user4" class="com.kuang.pojo.User">
        <constructor-arg type="java.lang.String" value="kuangshen4"/>
    </bean>

</beans>

測試類

package com.kuang.pojo;

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

public class UserTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User)context.getBean("user");
        /*
        User user = new User();
        user.setName("qinjiang");
        */
        System.out.println(user.toString());
    }


    @Test
    public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user4");
        System.out.println(user);

    }



}

測試結果：

小結：

• 通過有參構造
  • 通過下標
  • 通過參數名 【推薦】
  • 通過參數類型
• 通過無參構造
  • 默認會用無參構造

注意點：一定要有一個無參構造方法

想多瞭解一點的可以查查：通過工廠模式創建

Spring配置文件

bean

<!--bean講解：
1.沒有id，沒有name，我們依舊可以獲取這個對象，但是不建議使用、需要使用類的class對象獲取；
    User bean = context.getBean(User.class);

2.id 就是對象的名字
3.class 就是要實例化的類
4.name就是別名
    有id的時候，name是別名 ， 沒有id的時候，name就是對象的名字
    別名可以起多個
-->
<bean id="user" name="userTwo,user3" class="com.kuang.pojo.User">
    <property name="name" value="Spring"/>
</bean>

alias

<!--alias講解：
1. name ： 就是bean對象的id
2,alias ： 對象的別名
-->
<alias name="user" alias="user4"/>

import

<!--import講解
作用：導入另外一個資源，把另外配置文件裝進來
    classpath*: 他會去所有地方尋找你的文件。【效率低】
    classpath: 只會在classpath中尋找文件，找不到就報錯；【建議使用】
    file：填寫文件路徑url【不建議使用】
    http：填寫網絡路徑url【不建議使用】
-->
<import resource="classpath*:userBeans.xml"/>
<import resource="classpath:userBeans.xml"/>
<import resource="file:"/>
<import resource="http:"/>

import一般在團隊項目中會使用，每個人開發各自的beans.xml，最後用一個總的文件拼裝起來。

依賴注入DI

依賴注入

DI （Dependency Injection）

依賴：指bean對象的創建依賴於Spring容器。bean對象依賴的資源

注入：指Bean對象所依賴的資源，由容器來設置和裝配。

構造器注入

• 有參
• 無參

setter注入

要求被注入的屬性，必須有set方法。set方法的名字需要規範

set+屬性名（屬性名字母大寫）；

1.1 常量注入

<!--普通字段-->
<property name="name" value="小明"/>

1.2 Bean注入

<!--引用其他bean使用ref-->
<property name="address" ref="addr"/>

1.3 數組注入

<!--數組的注入-->
<property name="books">
    <array>
        <value>西遊記</value>
        <value>水滸傳</value>
        <value>紅樓夢</value>
        <value>三國演義</value>
    </array>
</property>

1.4 List注入

<!--List注入-->
<property name="hobbys">
   <list>
       <value>女孩</value>
       <value>代碼</value>
       <value>電影</value>
       <value>音樂</value>
   </list>
</property>

1.5 Map注入

標籤：entry

鍵：使用key

值: 使用value

<!--Map的注入-->
<property name="card">
    <map>
        <entry key="IdCard" value="666666888888884444"/>
        <entry key="銀行卡" value="111122223333444"/>
    </map>
</property>

1.6 Set注入

<!--Set注入-->
<property name="games">
    <set>
        <value>王者榮耀</value>
        <value>貪玩藍月</value>
        <value>絕地求生</value>
        <value>LOL</value>
    </set>
</property>

1.7 空值注入

<!--Null空值注入-->
<property name="girlFriend">
    <null/>
</property>

1.8 Properties注入

props標籤

鍵使用key

值，在標籤中間；

<!--Properties注入-->
<property name="info">
    <props>
        <prop key="學號">201932301</prop>
        <prop key="性別">男</prop>
        <prop key="姓名">小明</prop>
    </props>
</property>

拓展1：p命名空間注入

<!--p：property屬性，命名空間注入-->
<bean id="user1" class="com.kuang.pojo.User" p:name="狂神" p:age="18"/>

拓展2：c命名空間注入

<!--c：constructor構造器：命名空間注入-->
<bean id="user2" class="com.kuang.pojo.User" c:name="狂神" c:age="19"/>

Spring就是一個粘合劑，託管所有的對象；

案例：

項目結構：

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>com.kuang</groupId>
    <artifactId>spring-study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>Spring01</module>
        <module>Spring02</module>
        <module>Spring03</module>
        <module>Spring04</module>
        <module>Spring05</module>
        <module>Spring06</module>
        <module>Spring07</module>
    </modules>


    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.9.RELEASE</version>
        </dependency>

    </dependencies>


</project>

pojo 實體類：
Address:

package com.kuang.pojo;

public class Address {

    private String address;

    //默認存在無參構造

    public void setAddress(String address) {
        this.address = address;
    }

    public String getAddress() {
        return address;
    }
}

Student:

package com.kuang.pojo;

import java.util.*;

public class Student {

    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private String girlFriend; //null
    private Properties info;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbys() {
        return hobbys;
    }

    public void setHobbys(List<String> hobbys) {
        this.hobbys = hobbys;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getGirlFriend() {
        return girlFriend;
    }

    public void setGirlFriend(String girlFriend) {
        this.girlFriend = girlFriend;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address.toString() +
                ", books=" + Arrays.toString(books) +
                ", hobbys=" + hobbys +
                ", card=" + card +
                ", games=" + games +
                ", girlFriend='" + girlFriend + '\'' +
                ", info=" + info +
                '}';
    }
}

User:

package com.kuang.pojo;

public class User {

    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--Address-->
    <!--
    作用域scope：
    Web相關
        request
        session
        singleton：單例模式
        prototype: 原型
    bean中不填寫作用域默認， scope="singleton"，單例
        單例：在內存中只有一個備份
    -->
    <bean id="addr" class="com.kuang.pojo.Address">
        <property name="address" value="西安"/>
    </bean>

    <!--Student-->
    <bean id="student" class="com.kuang.pojo.Student">
        <!--普通字段-->
        <property name="name" value="小明"/>
        <!--引用其他bean使用ref-->
        <property name="address" ref="addr"/>

        <!--數組的注入-->
        <property name="books">
            <array>
                <value>西遊記</value>
                <value>水滸傳</value>
                <value>紅樓夢</value>
                <value>三國演義</value>
            </array>
        </property>

        <!--List注入-->
        <property name="hobbys">
            <list>
                <value>女孩</value>
                <value>代碼</value>
                <value>電影</value>
                <value>音樂</value>
            </list>
        </property>

        <!--Map的注入-->
        <property name="card">
            <map>
                <entry key="IdCard" value="666666888888884444"/>
                <entry key="銀行卡" value="111122223333444"/>
            </map>
        </property>

        <!--Set注入-->
        <property name="games">
            <set>
                <value>王者榮耀</value>
                <value>貪玩藍月</value>
                <value>絕地求生</value>
                <value>LOL</value>
            </set>
        </property>

        <!--Null空值注入-->
        <property name="girlFriend">
            <null/>
        </property>

        <!--Properties注入-->
        <property name="info">
            <props>
                <prop key="學號">201932301</prop>
                <prop key="性別">男</prop>
                <prop key="姓名">小明</prop>
            </props>
        </property>

    </bean>

    <!--p：property屬性，命名空間注入-->
    <bean id="user1" class="com.kuang.pojo.User" p:name="狂神" p:age="18"/>

    <!--c：constructor構造器：命名空間注入-->
    <bean id="user2" class="com.kuang.pojo.User" c:name="狂神" c:age="19" />

</beans>

測試類：

package com.kuang.pojo;

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

public class TestSpring {

    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());
    }

    @Test
    public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");


        User user = (User) context.getBean("user1");
        User user1 = (User) context.getBean("user1");
        User user2 = (User) context.getBean("user1");
        User user3 = (User) context.getBean("user1");

        System.out.println(user.hashCode());
        System.out.println(user1.hashCode());
        System.out.println(user2.hashCode());
        System.out.println(user3.hashCode());


    }


}

輸出結果：

Bean作用域及自動裝配

在Spring中，那些組成應用程序的主體及由SpringIOC容器所管理的對象，被稱之爲bean。簡單地講，bean就是由IOC容器初始化、裝配及管理的對象。

配置文件中定義 Bean 時，我們不但可以配置 Bean 的屬性值以及相互之間的依賴關係，還可以定義 Bean 的作用域 。作用域會對 Bean 的生命週期和創建方式產生影響 。

Bean 的作用域類型：

類型	說明
singleton	在 Spring 容器中僅存在一個 Bean 實例， Bean 以單例的形式存在，默認值。
prototype	每次從容器中調用 Bean 時，都會返回一個新的實例，即相當於執行 new XxxBean() 的實例化操作。
request	每次 http 請求都會創建一個新的 Bean ， 僅用於 WebApplicationContext 環境。request.setAttribute("","")
session	同一個 http Session 共享一個 Bean ，不同的 http Session 使用不同的 Bean，僅用於 WebApplicationContext 環境。session.setAttribute("","")
globalSession	同一個全局 Session 共享一個 bean, 用於 Porlet, 僅用於 WebApplication 環境。application.setAttribute("","")

Spring 以容器的方式，使得我們僅需配置，即可得到天然的單例模式。

在五種作用域中，request、session和globalSession三種作用域僅在web的應用中使用。

單例模式

【核心：對象在內存中只有一份】

餓漢式，懶漢式。—> static

區別：加載時機不同.