Spring基本認(rèn)識(shí)和入門(mén)使用超詳細(xì)教程

更新時(shí)間：2025年11月21日 11:23:53 作者：極客編程坊

Spring是一款主流的Java EE 輕量級(jí)開(kāi)源框架,目的是用于簡(jiǎn)化Java企業(yè)級(jí)引用的開(kāi)發(fā)難度和開(kāi)發(fā)周期,本文給大家介紹Spring基本認(rèn)識(shí)和入門(mén)使用超詳細(xì)教程,感興趣的朋友一起看看吧

Spring

spring概述

1 Spring定義

? Spring是一款主流的Java EE 輕量級(jí)開(kāi)源框架，目的是用于簡(jiǎn)化Java企業(yè)級(jí)引用的開(kāi)發(fā)難度和開(kāi)發(fā)周期。從簡(jiǎn)單性、可測(cè)試性和松耦合度的角度而言，任何Java應(yīng)用都可以從Spring中受益。Spring框架提供自己提供功能外，還提供整合其他技術(shù)和框架的能力。

? Spring自誕生以來(lái)備受青睞，一直被廣大開(kāi)發(fā)人員作為Java企業(yè)級(jí)應(yīng)用程序開(kāi)發(fā)的首選。時(shí)至今日，Spring儼然成為了Java EE的代名詞，成為了構(gòu)建Java EE 應(yīng)用的事實(shí)標(biāo)準(zhǔn)。

? 自2004年4月，Spring1.0 版正式發(fā)布以來(lái)，Spring已經(jīng)步入到了第6個(gè)大版本，即 Spring6，以下內(nèi)容采用Spring5.3.24正式版本。

2 Spring核心

? Spring指的是Spring Framework，通常我們稱(chēng)之為Spring框架。Spring框架是一個(gè)分層的面向切面的Java應(yīng)用程序的一站式解決框架，它是Spring技術(shù)棧的核心和基礎(chǔ)，是為了解決企業(yè)級(jí)引用開(kāi)發(fā)的復(fù)雜性而創(chuàng)建的。

? Spring有兩個(gè)核心模塊：IoC和AOP。

? Ioc：Inverse of Control的簡(jiǎn)寫(xiě)，為控制反轉(zhuǎn)，指把創(chuàng)建對(duì)象交給Spring進(jìn)行管理。

? AOP：Aspect Oriented Programming 的簡(jiǎn)寫(xiě)，為面向切面編程。AOP用來(lái)封裝多個(gè)類(lèi)的公共行為，將那些與業(yè)務(wù)無(wú)關(guān)，卻為業(yè)務(wù)模塊共同調(diào)用的邏輯封裝起來(lái)，減少系統(tǒng)的重復(fù)代碼，降低模塊間的耦合度。另外，AOP還解決一些系統(tǒng)層面上的問(wèn)題，比如日志、事務(wù)、權(quán)限等。

3 Spring Framework的特點(diǎn)

控制反轉(zhuǎn)：IoC，反轉(zhuǎn)資源獲取方向；把自己創(chuàng)建的資源、向環(huán)境索取資源變?yōu)榄h(huán)境將資源準(zhǔn)備好，我們享受資源注入。
面向切面編程：AOP，在不修改源代碼的基礎(chǔ)上增強(qiáng)代碼功能。
容器：Spring IoC是一個(gè)容器，因?yàn)樗⒐芾斫M件對(duì)象的生命周期；組件享受到了容器化的管理，替程序員屏蔽了組件創(chuàng)建過(guò)程中的大量細(xì)節(jié)，極大降低了使用門(mén)檻，大幅度提高了開(kāi)發(fā)效率。
一站式：在IOC和AOP的基礎(chǔ)上可以整合各種企業(yè)應(yīng)用的開(kāi)源框架和優(yōu)秀的第三方庫(kù)，而且在Spring旗下的項(xiàng)目已經(jīng)覆蓋了廣泛領(lǐng)域，很多方面的功能性需求可以在Spring Framework 的基礎(chǔ)上全部使用Spring來(lái)實(shí)現(xiàn)。

入門(mén)案例

1 環(huán)境要求

JDK：Java8-15
Spring：5.3.24

2 構(gòu)建工程

2.1 構(gòu)建子工程first-spring

? 在jsd2303-spring中創(chuàng)建子工程 spring-first

New - Module

點(diǎn)擊 Next

Name為spring-first，點(diǎn)擊 Finish

2.2 入門(mén)案例

① 在spring-first/pom.xml中引入相關(guān)依賴(lài)，并刷新maven

<dependencies>
    <!-- spring context依賴(lài)
             當(dāng)引入此依賴(lài)后，表示將Spring的基礎(chǔ)依賴(lài)引入了
         -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.24</version>
    </dependency>
</dependencies>

② 在工程中創(chuàng)建包 cn.tedu.spring.begin

③ 創(chuàng)建類(lèi) User

④ User類(lèi)中定義方法

public class User {
    public void add(){
        System.out.println("添加方法...");
    }
}

⑤ 創(chuàng)建spring配置文件：resources目錄下創(chuàng)建bean.xml

⑥ 在bean.xml中用標(biāo)簽完成對(duì)象創(chuàng)建

<?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">
    <!--完成user對(duì)象創(chuàng)建
        id屬性：唯一標(biāo)識(shí)
        class屬性：要?jiǎng)?chuàng)建的對(duì)象所在類(lèi)的絕對(duì)路徑
    -->
    <bean id="user" class="cn.tedu.spring.User"></bean>
</beans>

⑦ 創(chuàng)建測(cè)試類(lèi)cn.tedu.spring.TestUser進(jìn)行測(cè)試

public class TestUser {
    public static void main(String[] args) {
        // 1.加載spring配置文件，進(jìn)行對(duì)象創(chuàng)建
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 2.獲取spring創(chuàng)建好的對(duì)象
        User user = (User) context.getBean("user");
        // 3.使用對(duì)象調(diào)用方法測(cè)試
        System.out.println("user = " + user);
        user.add();
    }
}

2.3 對(duì)象存儲(chǔ)

存放到容器中，查看源碼，DefaultListableBeanFactory.java，第164行

key：唯一標(biāo)識(shí)

value：類(lèi)的定義（描述信息）

可以查看 BeanDefinition 的源碼，有類(lèi)的描述信息，是否初始化的狀態(tài)等等

IoC容器

? IoC 是 Inversion of Control 的簡(jiǎn)寫(xiě)，譯為控制反轉(zhuǎn)。

? Spring通過(guò)IoC容器來(lái)管理所有的Java對(duì)象的實(shí)例化和初始化，控制著對(duì)象與對(duì)象之間的依賴(lài)關(guān)系。我們將由IoC容器管理的Java對(duì)象成為 Spring Bean，它與使用關(guān)鍵字 new 創(chuàng)建的Java對(duì)象沒(méi)有任何區(qū)別。

? IoC容器是Spring框架中最重要的核心組件之一，它貫穿了Spring從誕生到成長(zhǎng)的整個(gè)過(guò)程。

1 控制反轉(zhuǎn)IoC

控制反轉(zhuǎn)是一種思想
- 將對(duì)象的創(chuàng)建權(quán)利交出去，交給第三方容器負(fù)責(zé)
- 將對(duì)象和對(duì)象之間的關(guān)系維護(hù)權(quán)交出去，交給第三方容器負(fù)責(zé)
如何實(shí)現(xiàn)
通過(guò)依賴(lài)注入DI的方式實(shí)現(xiàn)

2 依賴(lài)注入DI

DI （Dependency Injection）：依賴(lài)注入，依賴(lài)注入實(shí)現(xiàn)了控制反轉(zhuǎn)的思想，是指Spring創(chuàng)建對(duì)象的過(guò)程中，將對(duì)象依賴(lài)屬性通過(guò)配置進(jìn)行注入。

依賴(lài)注入常見(jiàn)的實(shí)現(xiàn)方式有兩種：

set注入
構(gòu)造注入

所以 IoC 是一種控制反轉(zhuǎn)的思想，而 DI 是對(duì)IoC的一種具體實(shí)現(xiàn)。

Bean管理：指Bean對(duì)象的創(chuàng)建，以及Bean對(duì)象中屬性的賦值（或Bean對(duì)象之間關(guān)系的維護(hù)）

3 IoC容器實(shí)現(xiàn)

Spring中的IoC容器就是IoC思想的一個(gè)落地產(chǎn)品實(shí)現(xiàn)。IoC容器中管理的組件也叫做bean。在創(chuàng)建bean之前，首先需要?jiǎng)?chuàng)建IoC容器，Spring提供了IoC容器的兩種實(shí)現(xiàn)方式

① BeanFactory

? 這是IoC容器的基本實(shí)現(xiàn)，是Spring內(nèi)部使用的接口。面向Spring本身，不提供給開(kāi)發(fā)人員使用。

② ApplicationContext

? BeanFactory的子接口，提供了更多高級(jí)特性，面向Spring的使用者，幾乎所有場(chǎng)合都使用 ApplicationContext，而不是底層的BeanFactory

源碼說(shuō)明：

③ ApplicationContext的主要實(shí)現(xiàn)類(lèi)

類(lèi)型	說(shuō)明
ClassPathXmlApplicationContext	通過(guò)讀取類(lèi)路徑下的xml格式配置文件創(chuàng)建IoC容器對(duì)象
FileSystemApplicationContext	通過(guò)文件系統(tǒng)路徑讀取xml格式配置文件創(chuàng)建IoC容器對(duì)象

4 基于XML管理bean

4.1 環(huán)境準(zhǔn)備

① 創(chuàng)建子工程 spring-ioc-xml

② pom.xml中引入spring依賴(lài)，并刷新maven

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.24</version>
    </dependency>
</dependencies>

③ 創(chuàng)建spring配置文件：resources/bean.xml

④ 在工程目錄java下創(chuàng)建類(lèi) cn.tedu.spring.iocxml.User

public class User {
    private String username;
    private String password;
    public void userMethod(){
        System.out.println("userMethod執(zhí)行~~");
    }
}

4.2 獲取bean方式

根據(jù)id獲取

id屬性是bean的唯一標(biāo)識(shí)，所以根據(jù)bean標(biāo)簽的id屬性可以精確獲取到一個(gè)組件對(duì)象。

① bean.xml

<bean id="user" class="cn.tedu.spring.iocxml.User"></bean>

② 創(chuàng)建測(cè)試類(lèi)UserTest

public class UserTest {
    public static void main(String[] args) {
        // 1.加載配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 2.根據(jù)id獲取bean
        User user1 = (User) context.getBean("user");
        System.out.println("1-根據(jù)id獲取對(duì)象:" + user1);
        user1.userMethod();
    }
}

根據(jù)類(lèi)型獲取

User user2 = context.getBean(User.class);
System.out.println("2-根據(jù)類(lèi)型獲取bean:" + user2);
user2.userMethod();

根據(jù)id和類(lèi)型獲取

User user3 = context.getBean("user", User.class);
System.out.println("3-根據(jù)id和類(lèi)型獲取bean：" + user3);
user3.userMethod();

注意

當(dāng)根據(jù)類(lèi)型獲取bean時(shí)，要求IoC容器中指定類(lèi)型的bean只能有一個(gè)，當(dāng)配置兩個(gè)時(shí)會(huì)拋出異常

<bean id="user" class="cn.tedu.spring.iocxml.User"></bean>
<bean id="user2" class="cn.tedu.spring.iocxml.User"></bean>

4.3 基于setter依賴(lài)注入

類(lèi)有屬性，創(chuàng)建對(duì)象過(guò)程中，向?qū)傩宰⑷刖唧w的值

方式1：使用set方法完成（使用xml中的標(biāo)簽實(shí)現(xiàn)）

方式2：基于構(gòu)造器完成

案例

① 創(chuàng)建Package名為dibase，創(chuàng)建Book類(lèi)

package cn.tedu.spring.DI;
public class Book {
    private String bookName;
    private String bookAuthor;
    // 無(wú)參構(gòu)造函數(shù)
    public Book() {}
    // 全參構(gòu)造函數(shù)
    public Book(String bookName, String bookAuthor) {
        this.bookName = bookName;
        this.bookAuthor = bookAuthor;
    }
    public String getBookName() {
        return bookName;
    }
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
    public String getBookAuthor() {
        return bookAuthor;
    }
    public void setBookAuthor(String bookAuthor) {
        this.bookAuthor = bookAuthor;
    }
    @Override
    public String toString() {
        return "Book{" +
                "bookName='" + bookName + '\'' +
                ", bookAuthor='" + bookAuthor + '\'' +
                '}';
    }
}

② 創(chuàng)建spring配置文件：resources目錄下創(chuàng)建 bean-di.xml

<!-- set方法注入 -->
<bean id="book" class="cn.tedu.spring.DI.Book">
    <!--2.使用property標(biāo)簽注入-->
    <property name="bookName" value="java"></property>
    <property name="bookAuthor" value="tedu"></property>
</bean>

③ 創(chuàng)建測(cè)試類(lèi)TestBook進(jìn)行測(cè)試

public class BookTest {
    // spring的set方法注入
    @Test
    public void springSetTest(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-di.xml");
        Book book = context.getBean("book", Book.class);
        System.out.println("book = " + book);
    }
}

4.4 基于構(gòu)造器依賴(lài)注入

說(shuō)明
- 通過(guò)構(gòu)造器方式實(shí)現(xiàn)依賴(lài)注入
- 操作步驟說(shuō)明
- 創(chuàng)建類(lèi)，定義屬性，生成有參數(shù)構(gòu)造方法
進(jìn)行xml配置
創(chuàng)建測(cè)試類(lèi)測(cè)試

① 創(chuàng)建電影信息類(lèi)Film，定義屬性并生成全參構(gòu)造方法

public class Film {
    // 電影名稱(chēng)、主演
    private String title;
    private String actor;
    // 全參構(gòu)造
    public Film(String title, String actor) {
        System.out.println("Film的有參構(gòu)造已經(jīng)執(zhí)行~~");
        this.title = title;
        this.actor = actor;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getActor() {
        return actor;
    }
    public void setActor(String actor) {
        this.actor = actor;
    }
    @Override
    public String toString() {
        return "Film{" +
                "title='" + title + '\'' +
                ", actor='" + actor + '\'' +
                '}';
    }
}

② 在bean-di.xml中進(jìn)行注入配置

<!-- 構(gòu)造器注入演示：Film類(lèi) -->
<bean id="film" class="cn.tedu.spring.DI.Film">
    <constructor-arg name="title" value="霸王別姬"></constructor-arg>
    <constructor-arg name="actor" value="張國(guó)榮"></constructor-arg>
</bean>

③ 創(chuàng)建測(cè)試類(lèi)TestFilm測(cè)試

public class FilmTest {
    @Test
    public void FilmConsDITest(){
        // 1.加載配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-di.xml");
        // 2.獲取指定bean
        Film film = context.getBean("film", Film.class);
        // 3.輸出測(cè)試
        System.out.println("film = " + film);
    }
}

4.5 特殊值處理注入

4.5.1 字面量賦值

string number = 10;

聲明一個(gè)變量number，初始化為 10，此時(shí)number就不代表字符number了，而是作為一個(gè)變量的名字。當(dāng)引用number時(shí)，實(shí)際拿到的結(jié)果是 10。

而如果number是帶引號(hào)的 “number” ，則它不是一個(gè)變量，而代表 number 本身這個(gè)字符串。

這就是字面量，所以字面量沒(méi)有引申含義，就是我們看到的這個(gè)數(shù)據(jù)本身。

<!-- 使用value屬性給bean的屬性賦值時(shí)，spring會(huì)把value的屬性值看作是字面量 -->
<property name="number" value="1016"></property>

4.5.2 null值

使用標(biāo)簽，或者標(biāo)簽實(shí)現(xiàn)注入。

① Film類(lèi)中增加電影描述屬性

// 1.電影描述
private String description;
// 2.生成對(duì)應(yīng)的 set() get() 方法，重新生成toString()方法
// 3.重新生成全參構(gòu)造方法

② bean-di.xml配置文件調(diào)整

<!-- 構(gòu)造器注入演示：Film類(lèi) -->
<bean id="film" class="cn.tedu.spring.DI.Film">
    <constructor-arg name="title" value="霸王別姬"></constructor-arg>
    <constructor-arg name="actor" value="張國(guó)榮"></constructor-arg>
    <!-- 電影描述注入空值null -->
    <constructor-arg name="description">
        <null></null>
    </constructor-arg>
</bean>

③ 執(zhí)行測(cè)試類(lèi)進(jìn)行測(cè)試

課堂練習(xí)
cn.tedu.spring下創(chuàng)建包exercise，在包下創(chuàng)建商品表 Product，類(lèi)屬性如下：
商品標(biāo)題：title
商品庫(kù)存：num
商品銷(xiāo)量：sales
商品描述：comment
- 實(shí)現(xiàn) 商品Product類(lèi)的創(chuàng)建，setter() getter() toString()，
- 通過(guò)配置文件bean-product.xml
- 通過(guò)set方式注入一組數(shù)據(jù)（商品描述為null值）；
- 通過(guò)構(gòu)造參數(shù)方式注入一組數(shù)據(jù)（商品描述為null值）；
創(chuàng)建測(cè)試類(lèi)TestProduct進(jìn)行測(cè)試。
練習(xí)答案

① Product類(lèi)

public class Product {
    private String title;
    private Integer num;
    private Integer sales;
    private String comment;
    // 無(wú)參構(gòu)造函數(shù)、有參構(gòu)造函數(shù)  setter() getter() toString() 
}

② bean-product.xml

<!-- set方法注入 -->
<bean id="product" class="cn.tedu.spring.exercise.Product">
    <property name="title" value="手機(jī)"></property>
    <property name="num" value="100"></property>
    <property name="sales" value="1000"></property>
    <property name="comment">
        <null></null>
    </property>
</bean>
<!-- 構(gòu)造參數(shù)方法注入 -->
<bean id="productCons" class="cn.tedu.spring.exercise.Product">
    <constructor-arg name="title" value="電腦"/>
    <constructor-arg name="num" value="2"/>
    <constructor-arg name="sales" value="3"/>
    <constructor-arg name="comment">
        <null></null>
    </constructor-arg>
</bean>

③ ProductTest測(cè)試類(lèi)

@Test
public void testProduct(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean-product.xml");
    Product product = context.getBean("product", Product.class);
    System.out.println("product = " + product);
}

4.5.3 xml實(shí)體

說(shuō)明
- < > 小于號(hào)、大于號(hào)在XML文檔中用來(lái)定義標(biāo)簽的開(kāi)始，具有特殊含義，在注入屬性值時(shí)不能夠隨便使用，
- 可以使用XML實(shí)體 < > 來(lái)代替
表示方式

普通字符	xml實(shí)體
<	<
>	>

查看示例 bean-di.xml：

<!-- xml實(shí)體 -->
<bean id="filmEntity" class="cn.tedu.spring.DI.Film">
    <constructor-arg name="title" value="霸王別姬"></constructor-arg>
    <constructor-arg name="actor" value="張國(guó)榮"></constructor-arg>
    <!--xml實(shí)體表示-->
    <constructor-arg name="description" value="<真好看啊電影>"></constructor-arg>
</bean>

4.5.4 CDATA區(qū)

CDATA區(qū)，是xml中一種特有的寫(xiě)法，在CDATA區(qū)中可以包含特殊符號(hào)

表示方式：

? <![CDATA[內(nèi)容]]> ，在內(nèi)容區(qū)域可以存放普通字符和特殊符號(hào)

CDATA區(qū)存放特殊符號(hào)演示

<!-- xml實(shí)體-CDATA區(qū) -->
<bean id="filmCdata" class="cn.tedu.spring.DI.Film">
    <constructor-arg name="title" value="霸王別姬"></constructor-arg>
    <constructor-arg name="actor" value="張國(guó)榮"></constructor-arg>
    <!--xml實(shí)體表示-->
    <constructor-arg name="description">
        <!-- CDATA區(qū)存放數(shù)據(jù)，可通過(guò) CD + Tab鍵自動(dòng)補(bǔ)全格式 -->
        <value><![CDATA[<真好看啊>]]></value>
    </constructor-arg>
</bean>

4.6 對(duì)象類(lèi)型屬性注入

需要注入的數(shù)據(jù)類(lèi)型為對(duì)象，而不是一個(gè)字面量。

環(huán)境準(zhǔn)備
準(zhǔn)備一個(gè)一對(duì)多案例，比如部門(mén)Dept和員工Emp是一對(duì)多的關(guān)系。

① 創(chuàng)建包diobj，并創(chuàng)建部門(mén)類(lèi)Dept

public class Dept {
    // 部門(mén)名稱(chēng)
    private String dName;
    // 定義方法，用于測(cè)試輸出
    public void deptFunc(){
        System.out.println("Dept部門(mén)名稱(chēng)：" + dName);
    }
    public void setdName(String dName) {
        this.dName = dName;
    }
    public String getdName() {
        return dName;
    }
    @Override
    public String toString() {
        return "Dept{" +
                "dName='" + dName + '\'' +
                '}';
    }
}

② 創(chuàng)建員工類(lèi)Emp，創(chuàng)建setter() getter() 和 toString()方法

public class Emp {
    // 員工所屬部門(mén)的對(duì)象、姓名、工資
    private Dept dept;
    private String eName;
    private Double salary;
    // 定義方法測(cè)試
    public void work(){
        System.out.println(eName + "薪資:" + salary);
        dept.deptFunc();
    }
    public void setDept(Dept dept) {
        this.dept = dept;
    }
    public void seteName(String eName) {
        this.eName = eName;
    }
    public void setSalary(Double salary) {
        this.salary = salary;
    }
    public Dept getDept() {
        return dept;
    }
    public String geteName() {
        return eName;
    }
    public Double getSalary() {
        return salary;
    }
    @Override
    public String toString() {
        return "Emp{" +
                "dept=" + dept +
                ", eName='" + eName + '\'' +
                ", salary=" + salary +
                '}';
    }
}

4.6.1 引用外部bean

說(shuō)明：

? 可以通過(guò)在當(dāng)前bean標(biāo)簽中通過(guò) ref屬性引用外部bean的方式實(shí)現(xiàn)。

示例：通過(guò)使用外部bean方式，在員工中注入部門(mén)對(duì)象

① 配置文件 bean-diobj.xml

<!--在Emp中注入Dept
    方式1：引用外部bean
        1.創(chuàng)建兩個(gè)類(lèi)對(duì)象：dept 和 emp
        2.在emp的bean標(biāo)簽中，通過(guò)property標(biāo)簽注入dept的bean
    -->
<bean id="dept1" class="cn.tedu.spring.diobj.Dept">
    <property name="dName" value="開(kāi)發(fā)部"></property>
</bean>
<bean id="emp1" class="cn.tedu.spring.diobj.Emp">
    <!-- 普通屬性注入 -->
    <property name="eName" value="張三豐"></property>
    <property name="salary" value="50000.0"></property>
    <!-- 對(duì)象類(lèi)型注入，使用ref屬性 -->
    <property name="dept" ref="dept1"></property>
</bean>

② 創(chuàng)建測(cè)試類(lèi)測(cè)試 TestDept

public class TestDept {
    // 對(duì)象類(lèi)型注入測(cè)試用例
    @Test
    public void testObjDI(){
        // 1.加載xml配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-diobj.xml");
        // 2.獲取bean對(duì)象
        Emp emp1 = context.getBean("emp1", Emp.class);
        // 3.測(cè)試(調(diào)用員工emp對(duì)象的方法)
        System.out.println("emp1 = " + emp1);
        emp1.work();
    }
}

4.6.2 內(nèi)部bean

在需要注入對(duì)象的bean標(biāo)簽中內(nèi)嵌對(duì)象類(lèi)型屬性的 bean標(biāo)簽即可。

? 內(nèi)嵌bean

① bean-diobj.xml進(jìn)行屬性注入配置

<!--在Emp中注入Dept
        方式2：引用內(nèi)部bean
            在emp的bean標(biāo)簽中，通過(guò)內(nèi)嵌部門(mén)bean標(biāo)簽方式實(shí)現(xiàn)
        -->
<bean id="emp2" class="cn.tedu.spring.diobj.Emp">
    <property name="eName" value="張無(wú)忌"/>
    <property name="salary" value="8000.0"/>
    <!--對(duì)象注入-->
    <property name="dept">
        <bean id="dept2" class="cn.tedu.spring.diobj.Dept">
            <property name="dName" value="銷(xiāo)售部"/>
        </bean>
    </property>
</bean>

② 使用測(cè)試類(lèi)測(cè)試

// 對(duì)象類(lèi)型注入：內(nèi)嵌bean
@Test
public void testObjDi2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean-diobj.xml");
    Emp emp2 = context.getBean("emp2", Emp.class);
    System.out.println("emp2 = " + emp2);
    emp2.work();
}

4.6.3 級(jí)聯(lián)屬性賦值（了解）

可以在標(biāo)簽中給需要注入對(duì)象的屬性重新賦值！

① 配置文件編寫(xiě)

<!--方式3：級(jí)聯(lián)屬性(需要注入的屬性)賦值-->
<bean id="dept3" class="cn.tedu.spring.diobj.Dept">
    <property name="dName" value="市場(chǎng)部"/>
</bean>
<bean id="emp3" class="cn.tedu.spring.diobj.Emp">
    <!-- 普通屬性注入 -->
    <property name="eName" value="趙敏"/>
    <property name="salary" value="5000.0"/>
    <!-- 對(duì)象類(lèi)型注入 -->
    <property name="dept" ref="dept3"/>
    <!-- 級(jí)聯(lián)屬性(Dept)賦值 -->
    <property name="dept.dName" value="客服部"></property>
</bean>

② 測(cè)試類(lèi)測(cè)試

// 對(duì)象類(lèi)型注入：級(jí)聯(lián)屬性賦值
@Test
public void testObjDi3(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean-diobj.xml");
    Emp emp3 = context.getBean("emp3", Emp.class);
    System.out.println("emp3 = " + emp3);
    emp3.work();
}

4.7 數(shù)組類(lèi)型屬性注入

使用標(biāo)簽和子標(biāo)簽實(shí)現(xiàn)。

說(shuō)明：一個(gè)人除了姓名、年齡等屬性外，還會(huì)有愛(ài)好，一個(gè)人的愛(ài)好可能有多個(gè)，可以把多個(gè)愛(ài)好存入數(shù)組中。

創(chuàng)建包：cn.tedu.spring.diarray

① 在diarray包中創(chuàng)建類(lèi)：Person

public class Person {
    // 姓名、年齡、愛(ài)好
    private String name;
    private String age;
    private String[] hobby;
    // 定義測(cè)試方法
    public void run(){
        System.out.println("Persen is running...");
        // 打印數(shù)組測(cè)試
        System.out.println(Arrays.toString(hobby));
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String[] getHobby() {
        return hobby;
    }
    public void setHobby(String[] hobby) {
        this.hobby = hobby;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", hobby=" + Arrays.toString(hobby) +
                '}';
    }
}

② 新建配置文件：bean-diarray.xml 進(jìn)行注入

<!-- 創(chuàng)建Person對(duì)象并注入屬性 -->
<bean id="person" class="cn.tedu.spring.diarray.Person">
    <!-- 普通屬性注入 -->
    <property name="name" value="孫悟空"/>
    <property name="age" value="36"/>
    <!-- 數(shù)組屬性注入，使用<array>標(biāo)簽 -->
    <property name="hobby">
        <array>
            <value>抽煙</value>
            <value>喝酒</value>
            <value>燙頭</value>
        </array>
    </property>
</bean>

③ 編寫(xiě)測(cè)試類(lèi)TestPerson測(cè)試

public class TestPerson {
    // 數(shù)組注入測(cè)試用例
    @Test
    public void testArray(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-diarray.xml");
        Person person = context.getBean("person", Person.class);
        System.out.println("person = " + person);
        person.run();
    }
}

4.8 集合類(lèi)型屬性注入

4.8.1 List集合屬性注入

場(chǎng)景1：使用標(biāo)簽下的子標(biāo)簽和子標(biāo)簽實(shí)現(xiàn)。

場(chǎng)景2：使用標(biāo)簽下的子標(biāo)簽和子標(biāo)簽實(shí)現(xiàn)。ref標(biāo)識(shí)引用其他的bean

環(huán)境說(shuō)明：創(chuàng)建老師類(lèi)Student和學(xué)生類(lèi)Student，一個(gè)老師可以有多個(gè)學(xué)生，在老師類(lèi)中存入所教學(xué)生的對(duì)象，將其存入List集合中。

環(huán)境準(zhǔn)備

① 創(chuàng)建包 dimap

② Teacher類(lèi)

public class Teacher {
    // 老師姓名
    private String tName;
    // 老師所教學(xué)生的對(duì)象，放到List集合中
    private List<Student> studentList;
    public String gettName() {
        return tName;
    }
    public void settName(String tName) {
        this.tName = tName;
    }
    public List<Student> getStudentList() {
        return studentList;
    }
    public void setStudentList(List<Student> studentList) {
        this.studentList = studentList;
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "tName='" + tName + '\'' +
                ", studentList=" + studentList +
                '}';
    }
}

③ Student類(lèi)

public class Student {
    // 學(xué)生姓名、年齡
    private String sName;
    private String age;
    public String getsName() {
        return sName;
    }
    public void setsName(String sName) {
        this.sName = sName;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "sName='" + sName + '\'' +
                ", course='" + course + '\'' +
                '}';
    }
}

④ 創(chuàng)建配置文件：bean-dilistmap.xml 進(jìn)行注入

<!-- 創(chuàng)建2個(gè)Student對(duì)象，用于Teacher對(duì)象的注入 -->
<bean id="stu1" class="cn.tedu.spring.dimap.Student">
    <property name="sName" value="梁山伯"/>
    <property name="age" value="43"/>
</bean>
<bean id="stu2" class="cn.tedu.spring.dimap.Student">
    <property name="sName" value="祝英臺(tái)"/>
    <property name="age" value="33"/>
</bean>
<!-- 創(chuàng)建Teacher類(lèi)的bean對(duì)象，并注入屬性 -->
<bean id="teacher" class="cn.tedu.spring.dimap.Teacher">
    <!-- 普通屬性注入 -->
    <property name="tName" value="沙師弟"/>
    <!-- List集合屬性注入 -->
    <property name="studentList">
        <list>
            <ref bean="stu1"/>
            <ref bean="stu2"/>
        </list>
    </property>
</bean>

⑤ 測(cè)試類(lèi)TestTeacher測(cè)試

public class TestTeacher {
    @Test
    public void testListMap(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-dilistmap.xml");
        Teacher teacher = context.getBean("teacher", Teacher.class);
        System.out.println("teacher = " + teacher);
        List<Student> list = teacher.getStudentList();
        for (Student student: list) {
            System.out.println(student);
        }
    }
}

4.8.2 Map集合屬性注入

使用標(biāo)簽下的子標(biāo)簽、子標(biāo)簽、子標(biāo)簽子標(biāo)簽子標(biāo)簽實(shí)現(xiàn)

<bean id="xxx" class="xxx">
	<property name="xxx">
        <map>
            <!-- 第1條數(shù)據(jù)-字面量值演示 -->
			<entry>
            	<key><value>xxx</value></key>
                <value>xxx</value>
            </entry>
            <!-- 第2條數(shù)據(jù)-對(duì)象演示 -->
			<entry>
            	<key><value>xxx</value></key>
                <ref bean="xxx"></ref>
            </entry>
        </map>
	</property>
</bean>

說(shuō)明：使用上述的老師類(lèi)和學(xué)生類(lèi)，一個(gè)學(xué)生也可以有多個(gè)老師，在學(xué)生類(lèi)Student中添加老師的屬性，放到Map集合中。

① 調(diào)整Student類(lèi)

// 1.學(xué)生的老師：可以有多個(gè)，放到Map集合中
private Map<String,String> teacherMap;
// 2.生成setter() getter()方法，重新生成toString()方法

② 創(chuàng)建配置文件：bean-dimap.xml

<!--Map集合屬性注入-->
<bean id="stuMap" class="cn.tedu.spring.dilistmap.Student">
    <property name="sName" value="步驚云"/>
    <property name="age" value="36"/>
    <property name="teacherMap">
        <map>
            <entry>
                <key>
                    <value>1111</value>
                </key>
                <value>雄霸</value>
            </entry>
            <entry>
                <key>
                    <value>2222</value>
                </key>
                <value>斷浪</value>
            </entry>
            <entry>
                <key>
                    <value>3333</value>
                </key>
                <value>大空翼</value>
            </entry>
        </map>
    </property>
</bean>

③ 創(chuàng)建測(cè)試類(lèi)進(jìn)行測(cè)試 TestMap

@Test
public void testMap(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean-dimap.xml");
    Student student = context.getBean("stuMap", Student.class);
    System.out.println("student = "  + student);
}

4.8.3 引用集合類(lèi)型bean注入

說(shuō)明
通過(guò)使用標(biāo)簽實(shí)現(xiàn)
使用步驟
在xml配置文件中引入util約束

<beans
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="
       http://www.springframework.org/schema/util
       http://www.springframework.org/schema/util/spring-util.xsd"
>
</beans>

使用util標(biāo)簽進(jìn)入注入

<!-- Map集合util標(biāo)簽 -->
<util:map id="xxx"></util:map>
<!-- List集合util標(biāo)簽 -->
<util:list id="xxx"></util:list>

環(huán)境準(zhǔn)備及操作步驟

添加課程類(lèi)，一個(gè)學(xué)生可以上多門(mén)課程

① 在Student類(lèi)中添加List集合屬性

// 1.一個(gè)學(xué)生可以上多門(mén)課程,把課程名稱(chēng)放到List集合中
    private List<String> courseList;
// 2.生成get和set方法
// 3.重新生成toString()方法

② 創(chuàng)建spring配置文件：bean-diref.xml，引入util約束

<!-- 添加3行帶有util的配置 -->
<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="
       http://www.springframework.org/schema/util
       http://www.springframework.org/schema/util/spring-util.xsd
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

③ 配置xml文件完成注入

<!--引用集合類(lèi)型bean注入-->
<bean id="stuUtil" class="cn.tedu.spring.dilistmap.Student">
    <property name="sName" value="孔慈"/>
    <property name="age" value="36"/>
    <property name="teacherMap" ref="teacherMap"></property>
    <property name="courseList" ref="courseList"></property>
</bean>
<util:map id="teacherMap">
    <entry>
        <key>
            <value>10000</value>
        </key>
        <value>小澤老師</value>
    </entry>
    <entry>
        <key>
            <value>10001</value>
        </key>
        <value>王老師</value>
    </entry>
</util:map>
<util:list id="courseList">
    <value>Spring</value>
    <value>SpringMVC</value>
    <value>MyBatis</value>
</util:list>

④ 創(chuàng)建測(cè)試方法進(jìn)行測(cè)試

// 引用集合類(lèi)型bean注入（util）
@Test
public void testRefBean(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean-diref.xml");
    Student student = context.getBean("stuUtil", Student.class);
    System.out.println("student = " + student);
}

4.9 p命名空間

這也是一種注入方式，可以在xml中定義命名空間或者叫名稱(chēng)空間，可以簡(jiǎn)化xml代碼。

在bean-diref.html中操作

① 在xml配置文件中定義命名空間

xmlns:p="http://www.springframework.org/schema/p"

② 在xml文件進(jìn)行命名空間屬性注入

<!-- p命名空間注入: 注入學(xué)生屬性 -->
<bean id="studentp" class="cn.tedu.spring.iocxml.dimap.Student" p:sid="100" p:sname="鐵錘妹妹" p:courseList-ref="courseList" p:teacherMap-ref="teacherMap">

③ 測(cè)試

// p命名空間注入測(cè)試用例
@Test
public void testRefP(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean-diref.xml");
    Student studentp = context.getBean("studentp", Student.class);
    System.out.println("studentp = " + studentp);
}

4.10 引入外部屬性文件

說(shuō)明
- ? 當(dāng)前所有的配置和數(shù)據(jù)都在xml文件中，一個(gè)文件中有很多bean，修改和維護(hù)起來(lái)很不方便，生產(chǎn)環(huán)境中會(huì)把特定的固定值放到外部文件中，然后引入外部文件進(jìn)行注入，比如數(shù)據(jù)庫(kù)連接信息。
示例
- 將外部文件中的數(shù)據(jù)引入xml配置文件進(jìn)行注入

① pom.xml中引入數(shù)據(jù)庫(kù)相關(guān)依賴(lài)，并刷新maven

<!-- MySQL驅(qū)動(dòng) -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.15</version>
</dependency>
<!-- 數(shù)據(jù)源，連接池依賴(lài) -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.21</version>
</dependency>

② resources目錄下創(chuàng)建外部屬性文件，一般為properties格式，定義數(shù)據(jù)庫(kù)信息，比如：jdbc.properties

jdbc.user=root
jdbc.password=root
jdbc.url=jdbc://mysql://localhost:3306/spring
jdbc.driver=com.mysql.cj.jdbc.Driver

③ 創(chuàng)建spring配置文件bean-jdbc.xml，引入context的命名空間

使用context可以為XML外部實(shí)體注入定義，使得解析器在解析XML文檔時(shí)可以正確地識(shí)別外部實(shí)體

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 引入外部屬性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <!-- 完成數(shù)據(jù)庫(kù)信息注入 -->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="driverClassName" value="${jdbc.driver}"></property>
    </bean>
</beans>

④ 創(chuàng)建包jdbc，包中創(chuàng)建測(cè)試類(lèi) TestJdbc

public class TestJdbc {
    // 外部文件屬性引入測(cè)試用例
    @Test
    public void demo02(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-jdbc.xml");
        DruidDataSource druidDataSource = context.getBean("druidDataSource", DruidDataSource.class);
        System.out.println(druidDataSource.getUrl());
    }
}

4.11 bean的作用域

說(shuō)明
- ? bean的作用域，是指在交給spring創(chuàng)建bean對(duì)象時(shí)，可以指定是單實(shí)例還是多實(shí)例，通過(guò)bean標(biāo)簽中的scope屬性來(lái)指定，默認(rèn)是單實(shí)例。
單實(shí)例和多實(shí)例
單實(shí)例
- 單實(shí)例（Singleton）是指某個(gè)類(lèi)只能創(chuàng)建唯一的一個(gè)實(shí)例對(duì)象，并且該類(lèi)提供一個(gè)全局的訪(fǎng)問(wèn)點(diǎn)（靜態(tài)方法）來(lái)讓外界獲取這個(gè)實(shí)例，常常用在那些只需要一個(gè)實(shí)例來(lái)處理所有任務(wù)的場(chǎng)景下，例如配置類(lèi)或數(shù)據(jù)庫(kù)連接池等。
多實(shí)例
- 多實(shí)例（Multiple Instance）則是指可以在同一個(gè)類(lèi)的定義下，創(chuàng)建多個(gè)實(shí)例對(duì)象。每個(gè)對(duì)象都是相互獨(dú)立的，有自己的狀態(tài)和行為；常常用于需要同時(shí)處理多個(gè)任務(wù)的場(chǎng)景。

在Spring中可以通過(guò)配置bean標(biāo)簽的scope屬性來(lái)之地那個(gè)bean的作用域范圍，具體如下

取值	含義	創(chuàng)建對(duì)象時(shí)機(jī)
singleton（默認(rèn)）	在IoC容器中，這個(gè)bean的對(duì)象為單實(shí)例	IoC容器初始化時(shí)
prototype	這個(gè)bean在IoC容器中有多個(gè)實(shí)例	獲取bean時(shí)

案例演示

① 創(chuàng)建包scope，并在包下創(chuàng)建類(lèi)Sku

public class Sku {
}

② 創(chuàng)建spring的配置文件：bean-scope.xml

<!-- singleton:單實(shí)例 -->
<!-- 之后改為prototype多實(shí)例測(cè)試 -->
<bean id="sku" class="cn.tedu.spring.scope.Sku" scope="singleton"></bean>

③ 創(chuàng)建測(cè)試類(lèi)TestOrders

@Test
public void testOrders(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean-scope.xml");
    Orders orders = context.getBean("orders", Orders.class);
    System.out.println("orders = " + orders);
    Orders orders1 = context.getBean("orders", Orders.class);
    System.out.println("orders1 = " + orders1);
}
// 單實(shí)例，sku1和sku2地址相同
// 多實(shí)例，sku1和sku2地址不同

4.12 bean的生命周期

是指一個(gè)bean對(duì)象從創(chuàng)建到銷(xiāo)毀的整個(gè)過(guò)程。

4.12.1 bean的完整生命周期

實(shí)例化階段（bean對(duì)象創(chuàng)建）
- 在這個(gè)階段中，容器會(huì)創(chuàng)建一個(gè)Bean的實(shí)例，并為其分配空間。這個(gè)過(guò)程可以通過(guò)構(gòu)造方法完成。
屬性賦值階段
- 在實(shí)例化完Bean之后，容器會(huì)把Bean中的屬性值注入到Bean中，這個(gè)過(guò)程可以通過(guò)set方法完成。
初始化階段（bean對(duì)象初始化）
- 在屬性注入完成后，容器會(huì)對(duì)Bean進(jìn)行一些初始化操作；
- 初始化之前：bean的后置處理器可以接收到bean，此處可以對(duì)bean做相關(guān)操作。
- 初始化之后：bean的后置處理器可以接收到bean，此處可以對(duì)bean做相關(guān)操作。
使用階段
- 初始化完成后，Bean就可以被容器使用了
銷(xiāo)毀階段
- 容器在關(guān)閉時(shí)會(huì)對(duì)所有的Bean進(jìn)行銷(xiāo)毀操作，釋放資源。

4.12.2 生命周期驗(yàn)證

① 創(chuàng)建包life，創(chuàng)建類(lèi)User

package cn.tedu.spring.life;
import org.springframework.beans.BeansException;
public class User {
    private String username;
    // 1.無(wú)參數(shù)構(gòu)造
    public User(){
        System.out.println("1-bean對(duì)象創(chuàng)建，調(diào)用無(wú)參數(shù)構(gòu)造。");
    }
    // 3.初始化階段
    public void initMethod(){
        System.out.println("3-bean對(duì)象初始化，調(diào)用指定的初始化方法");
    }
    // 5.銷(xiāo)毀階段
    public void destoryMethod(){
        System.out.println("5-bean對(duì)象銷(xiāo)毀，調(diào)用指定的銷(xiāo)毀方法");
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
        // 2.給bean對(duì)象屬性賦值
        System.out.println("2-通過(guò)set方法給bean對(duì)象賦值。");
    }
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                '}';
    }
}

② 創(chuàng)建spring配置文件 bean-life.xml

<bean id="user" class="cn.tedu.spring.iocxml.life.User" scope="singleton" 
      init-method="initMethod" destroy-method="destroyMethod">
    <property name="username" value="聶風(fēng)"></property>
</bean>

③ 創(chuàng)建測(cè)試類(lèi)TestUser測(cè)試

@Test
public void testUser(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean-life.xml");
    User user = context.getBean("user", User.class);
    // 4.bean對(duì)象初始化完成，可以使用
    System.out.println("4-bean對(duì)象初始化完成，開(kāi)發(fā)者可以使用了。");
    // 銷(xiāo)毀bean
    context.close();
}

④ 后置處理器處理演示，新建類(lèi)MyBeanPost

public class MyBeanPost implements BeanPostProcessor {
    // BeanPostProcessor接口
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("3之前:bean后置處理器，在初始化之前執(zhí)行。" + beanName + ":" + bean);
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("3之后:bean后置處理器，在初始化之后執(zhí)行。" + beanName + ":" + bean);
        return bean;
    }
}

⑤ 在spring的配置文件bean-life.xml中進(jìn)行后置處理器配置

<!-- bean的后置處理器需要放到IoC容器中才能生效 -->
<bean id="myBeanPost" class="cn.tedu.spring.life.MyBeanPost"></bean>

⑥ 運(yùn)行測(cè)試類(lèi)測(cè)試

4.12.3 bean生命周期擴(kuò)展

bean的初始化和銷(xiāo)毀應(yīng)用場(chǎng)景
- 初始化
  - 創(chuàng)建連接池
  - 加載資源文件
  - 進(jìn)行數(shù)據(jù)校驗(yàn)
銷(xiāo)毀
- 關(guān)閉連接池
- 保存數(shù)據(jù)
- 釋放占用的資源
- 后置處理器
實(shí)現(xiàn)自定義的Bean對(duì)象處理邏輯，比如在Bean實(shí)例化之前或者之后對(duì)Bean對(duì)象進(jìn)行自定義的修改，可以方便地實(shí)現(xiàn)自定義邏輯和修改Bean對(duì)象的行為。

4.13 基于xml自動(dòng)裝配

自動(dòng)裝配說(shuō)明：

根據(jù)指定的策略，在IoC容器中匹配某一個(gè)bean，自動(dòng)為指定的bean中的所依賴(lài)的類(lèi)類(lèi)型或者接口類(lèi)型屬性賦值。

環(huán)境準(zhǔn)備

① 創(chuàng)建包auto，創(chuàng)建部門(mén)和員工的兩個(gè)java類(lèi)

② 部門(mén)類(lèi) Dept

public class Dept {
    private String dName;
    @Override
    public String toString() {
        return "Dept{" +
                "dName='" + dName + '\'' +
                '}';
    }
    public String getdName() {
        return dName;
    }
    public void setdName(String dName) {
        this.dName = dName;
    }
}

③ 員工類(lèi) Emp

public class Emp {
    private String eName;
    private Dept dept;
    @Override
    public String toString() {
        return "Emp{" +
                "eName='" + eName + '\'' +
                ", dept=" + dept +
                '}';
    }
    public String geteName() {
        return eName;
    }
    public void seteName(String eName) {
        this.eName = eName;
    }
    public Dept getDept() {
        return dept;
    }
    public void setDept(Dept dept) {
        this.dept = dept;
    }
}

④ 創(chuàng)建spring配置文件bean-auto.xml

<!--通過(guò)byType和byName自動(dòng)裝配-->
<bean id="dept" class="cn.tedu.spring.iocxml.auto.Dept">
    <property name="dName" value="技術(shù)部"></property>
</bean>
<!--autowire="byType" 或者 autowire="byName"-->
<bean id="emp" class="cn.tedu.spring.iocxml.auto.Emp" autowire="byType">
    <property name="eName" value="步驚云"></property>
</bean>

⑤ 創(chuàng)建測(cè)試類(lèi)測(cè)試TestAuto

@Test
public void testAuto(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean-auto.xml");
    Emp emp = context.getBean("emp", Emp.class);
    System.out.println("emp = " + emp);
}

使用bean標(biāo)簽的autowire屬性設(shè)置自動(dòng)裝配效果；

自動(dòng)裝配方式：byType

? byType: 根據(jù)類(lèi)型匹配IoC容器中的某個(gè)兼容類(lèi)型的bean，為屬性自動(dòng)賦值；

? 1. 如果在IoC中，沒(méi)有任何一個(gè)兼容類(lèi)型的bean能夠?yàn)閷傩再x值，則改屬性不裝配，默認(rèn)值為null；

? 2. 如果在IoC中，有多個(gè)兼容類(lèi)型的bean能夠?yàn)閷傩再x值，則拋出異常 NoUniqueBeanDefinitionException

自動(dòng)裝配方式：byName

? byName：將自動(dòng)裝配的屬性名，作為bean的id在IoC容器中匹配相對(duì)應(yīng)的bean進(jìn)行賦值

5 基于注解管理bean

? 從Java5開(kāi)始，Java增加了對(duì)注解（Annotation）的支持，它是代碼中的一種特殊標(biāo)記，可以在編譯、類(lèi)加載和運(yùn)行時(shí)被讀取，執(zhí)行相應(yīng)的處理。開(kāi)發(fā)人員可以通過(guò)注解在不改變?cè)写a和邏輯的情況下，在源代碼中嵌入補(bǔ)充信息。

? Spring從2.5版本開(kāi)始提供了對(duì)注解技術(shù)的全面支持，我們可以使用注解來(lái)實(shí)現(xiàn)自動(dòng)裝配，簡(jiǎn)化Spring的xml配置。

Spring通過(guò)注解實(shí)現(xiàn)自動(dòng)裝配：

引入依賴(lài)
開(kāi)啟組件掃描
使用注解定義Bean
依賴(lài)注入

5.1 創(chuàng)建子工程

子工程：spring-ioc-annotation

在pom.xml中添加springframework的依賴(lài)，刷新maven

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.24</version>
    </dependency>
</dependencies>

5.2 開(kāi)啟組件掃描

? Spring默認(rèn)不使用注解裝配Bean，因此需要在Spring的xml配置中，通過(guò)context:component-scan元素開(kāi)啟Spring Beans的自動(dòng)掃描功能。開(kāi)啟此功能后，Spring會(huì)自動(dòng)從掃描指定的包（base-package屬性設(shè)置）及其子包下的所有類(lèi)，如果類(lèi)上使用了@Component注解，就將該類(lèi)裝配到容器中。

① 工程下創(chuàng)建包：cn.tedu.spring.bean

② resources目錄下創(chuàng)建spring配置文件 bean.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 2.開(kāi)啟組件掃描，讓spring可以通過(guò)注解方式實(shí)現(xiàn)bean管理，包括創(chuàng)建對(duì)象、屬性注入 -->
    <!-- base-package:掃描哪個(gè)包中的注解，在cn.tedu的包或者子包中建了類(lèi)，在
     類(lèi)上、屬性上、方法上加了spring的@Component注解，這里就能掃描到-->
    <context:component-scan base-package="cn.tedu.spring"></context:component-scan>
</beans>

5.3 使用注解定義Bean

Spring提供了以下多個(gè)注解，這些注解可以直接標(biāo)注在java類(lèi)上，將它們定義成Spring Bean。

注解	說(shuō)明
@Component	該注解用于描述Spring中的Bean，它是一個(gè)泛化的概念，僅僅標(biāo)識(shí)容器中的一個(gè)組件（Bean），并且可以作用在任何層次，例如Service層、Dao層等，使用時(shí)只需將該注解標(biāo)注在相應(yīng)的類(lèi)上即可。
@Respository	該注解用于數(shù)據(jù)訪(fǎng)問(wèn)層（Dao層）的類(lèi)標(biāo)識(shí)為Spring中的Bean，功能與@Component相同。
@Service	該注解通常作用在業(yè)務(wù)層（Service層），用于將業(yè)務(wù)層的類(lèi)標(biāo)識(shí)為Spring中的Bean，其功能與@Component相同。
@Controller	該注解通常作用在控制層（如SpringMVC的Controller），用于將控制層的類(lèi)標(biāo)識(shí)為Spring中的Bean，其功能與@Component相同。

③ 創(chuàng)建User類(lèi)，并添加注解

// value可以不寫(xiě)，默認(rèn)為類(lèi)名首字母小寫(xiě)
//@Component(value = "user")  // <bean id="user" class="xxx">
//@Repository
//@Service
@Controller
public class User {

}

④ 創(chuàng)建測(cè)試類(lèi)測(cè)試TestUser

public class TestUser {
    @Test
    public void testUser(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        User user = context.getBean("user", User.class);
        System.out.println("user = " + user);
    }
}

5.4 @Autowired注入

單獨(dú)使用@Autowired注解，默認(rèn)根據(jù)類(lèi)型裝配（byType）

@Autowired注解有一個(gè)required屬性，默認(rèn)值是true，表示在注入的時(shí)候要求被注入的Bean必須存在，如果不存在則報(bào)錯(cuò)。如果required屬性設(shè)置為false，表示注入的Bean存在或者不存在都沒(méi)關(guān)系，存在就注入，不存在也不報(bào)錯(cuò)。

5.4.1 屬性注入

① cn.tedu.spring下創(chuàng)建包autowired，并在autowired下創(chuàng)建兩個(gè)包：controller包和 service包

② 控制器層controller.UserController

public class UserController {
    private UserService userService;
    public void addController(){
        System.out.println("controller is running...");
        userService.addService();
    }
}

③ 服務(wù)層service.UserService接口

public interface UserService {
    public void addService();
}

④ 服務(wù)層service.UserServiceImpl接口的實(shí)現(xiàn)類(lèi)

public class UserServiceImpl implements UserService {
    @Override
    public void addService() {
        System.out.println("service is running...");
    }
}

⑤ 在UserController和UserSerivceImpl中添加@Controller注解和@Service注解

⑥ 在UserController中注入U(xiǎn)serServiceImpl

@Controller
public class UserController {
    // 注入service
    // 第一種方式：屬性注入
    @Autowired // 根據(jù)類(lèi)型找到對(duì)象，完成注入
    private UserService userService;
}

⑦ 測(cè)試類(lèi)測(cè)試autowired.TestUserController

public class TestUserController {
    @Test
    public void testUserController(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        UserController controller = context.getBean(UserController.class);
        controller.addController();
    }
}

5.4.2 set注入

① 修改UserController類(lèi)

// 方式二：通過(guò)set方法注入
private UserService userService;
@Autowired
public void setUserService(UserService userService) {
    this.userService = userService;
}

② 測(cè)試

5.4.3 構(gòu)造方法注入

① 修改UserController類(lèi)

// 第三種方式：構(gòu)造方法注入
private UserService userService;
@Autowired
public UserController(UserService userService) {
    this.userService = userService;
}

② 測(cè)試

5.4.4 形參上注入

① 修改UserController類(lèi)

// 第四種方式：形參注入
private UserService userService;
public UserController(@Autowired UserService userService) {
    this.userService = userService;
}

② 測(cè)試

5.4.5 只有一個(gè)構(gòu)造函數(shù)，無(wú)注解

① 修改UserController類(lèi)

// 第五種方式：只有一個(gè)有參數(shù)構(gòu)造函數(shù)，無(wú)注解
private UserService userService;
public UserController(UserService userService) {
    this.userService = userService;
}

② 測(cè)試

5.4.6 @Autowire注解和@Qualifier注解聯(lián)合

① 再創(chuàng)建一個(gè)UserService接口的實(shí)現(xiàn)類(lèi)service.UserServiceImpl2

@Service
public class UserServiceImpl2 implements UserService{
    @Override
    public void addService() {
        System.out.println("service2 is running...");
    }
}

② 測(cè)試發(fā)現(xiàn)報(bào)錯(cuò)

? 因?yàn)閁serService有兩個(gè)實(shí)現(xiàn)類(lèi)，而@Autowired注解根據(jù)byType定位，所以找到了兩個(gè)實(shí)現(xiàn)類(lèi)

③ 解決：修改UserController （使用兩個(gè)注解）

// 1.第六種方式：根據(jù)類(lèi)型和名稱(chēng)一起注入
@Autowired
@Qualifier(value = "userServiceImpl2")  // 類(lèi)名首字母小寫(xiě)
private UserService userService;
// 2.將構(gòu)造函數(shù)注釋

5.5 @Resource注入

@Resource注解也可以完成屬性注入。它和@Autowired注解的區(qū)別如下

@Resource注解是JDK擴(kuò)展包中的，也就是說(shuō)屬于JDK的一部分。所以該解釋是標(biāo)準(zhǔn)注解，更加具有通用性，而@Autowired注解是Spring框架自己的。
@Resource注解默認(rèn)根據(jù)名稱(chēng)裝配byName，未指定name時(shí)，使用屬性名作為name，通過(guò)name找不到的話(huà)會(huì)自動(dòng)啟動(dòng)通過(guò)類(lèi)型byType裝配。而@Autowired注解默認(rèn)根據(jù)類(lèi)型裝配byType，如果想根據(jù)名稱(chēng)匹配，需要配合@Qualifier注解一起使用。
@Resource注解用在屬性上、setter方法上
@Autowired注解用在屬性上、setter方法上、構(gòu)造方法上、構(gòu)造方法參數(shù)上。

案例演示

① 工程下創(chuàng)建包 resource，和之前一樣，創(chuàng)建controller和service兩個(gè)包，并創(chuàng)建UserController類(lèi)和UserService接口以及該接口的實(shí)現(xiàn)類(lèi)UserServiceImpl

② 修改UserController

@Controller("myUserController")
public class UserController {
    // 根據(jù)名稱(chēng)進(jìn)行注入
    @Resource(name="myUserService")
    private UserService userService;
    public void add(){
        System.out.println("controller...");
        userService.add();
    }
}

③ 修改ServiceControllerImpl1

@Service("myUserService")
public class UserServiceImpl implements UserService {

⑤ 測(cè)試

指定@Resource中的name，則根據(jù)名稱(chēng)裝配
未指定name時(shí)，則根據(jù)屬性名裝配
未指定name，屬性名也不一致，則根據(jù)類(lèi)型裝配

5.6 Spring全注解開(kāi)發(fā)

全注解開(kāi)發(fā)就是不再使用spring配置文件了，寫(xiě)一個(gè)配置類(lèi)來(lái)代替配置文件。

① 工程下創(chuàng)建包：config，創(chuàng)建類(lèi)SpringConfig

// 配置類(lèi)
@Configuration
// 開(kāi)啟組件掃描
@ComponentScan("cn.tedu.spring")
public class SpringConfig {
}

② 在resource下創(chuàng)建測(cè)試類(lèi)進(jìn)行測(cè)試

public class TestUserControllerAnno {
    public static void main(String[] args) {
        // 加載配置類(lèi)
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        UserController controller = context.getBean(UserController.class);
        controller.add();
    }
}

到此這篇關(guān)于spring全面詳解-最全最詳細(xì)的spring基本認(rèn)識(shí)和入門(mén)使用的文章就介紹到這了,更多相關(guān)spring內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: