JavaEE 突擊 5 - Spring 更簡(jiǎn)單的讀取和存儲(chǔ)對(duì)象(2)

這篇具有很好參考價(jià)值的文章主要介紹了JavaEE 突擊 5 - Spring 更簡(jiǎn)單的讀取和存儲(chǔ)對(duì)象(2)。希望對(duì)大家有所幫助。如果存在錯(cuò)誤或未考慮完全的地方，請(qǐng)大家不吝賜教，您也可以點(diǎn)擊"舉報(bào)違法"按鈕提交疑問(wèn)。

大家新年快樂(lè) , 祝大家新的一年如圖

這個(gè)專欄給大家介紹一下 Java 家族的核心產(chǎn)品 - SSM 框架
JavaEE 進(jìn)階專欄

Java 語(yǔ)言能走到現(xiàn)在 , 仍然屹立不衰的原因 , 有一部分就是因?yàn)?SSM 框架的存在

接下來(lái) , 博主會(huì)帶大家了解一下 Spring、Spring Boot、Spring MVC、MyBatis 相關(guān)知識(shí)點(diǎn)

并且?guī)ьI(lǐng)大家進(jìn)行環(huán)境的配置 , 讓大家真正用好框架、學(xué)懂框架

來(lái)上一篇文章復(fù)習(xí)一下吧
點(diǎn)擊即可跳轉(zhuǎn)到我的小秘密

本篇文章是基于在上一篇文章的進(jìn)一步講解 , 所以需要讀者有上一篇文章的基礎(chǔ)

三 . 獲取 Bean 對(duì)象

我們最早的方式是這樣的

package com.ethan.Controller;

import com.ethan.service.UserService;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    // 讀取 UserService
    public void sayHello() {
        UserService userService = new UserService();
        userService.doService();
    }
}

直接通過(guò) new 的方式我們是不推薦的
然后接下來(lái)進(jìn)入了 2.0 時(shí)代
我們?cè)O(shè)置一個(gè)啟動(dòng)類 , 在里面首先要得到得到上下文對(duì)象 , 然后去使用 getBean 得到 Bean 對(duì)象 , 最后再去操作 Bean 對(duì)象 , 這種方法還是不太簡(jiǎn)便
JavaEE 突擊 5 - Spring 更簡(jiǎn)單的讀取和存儲(chǔ)對(duì)象(2),JavaEE 新手入門,spring,java-ee,java
所以迎來(lái)了我們的 3.0 時(shí)代 : 依賴注入
獲取 bean 對(duì)象也叫做對(duì)象裝配，是把對(duì)象取出來(lái)放到某個(gè)類中，有時(shí)候也叫對(duì)象注入, 也叫做依賴注入(DI)

在程序運(yùn)行期間 , 將當(dāng)前類需要的對(duì)象動(dòng)態(tài)的引入到當(dāng)前的類當(dāng)中 , 這個(gè)過(guò)程就叫做依賴注入

對(duì)象裝配（對(duì)象注?）的實(shí)現(xiàn)?法以下 3 種：

屬性注入
Setter 注入
構(gòu)造方法注入

我們先來(lái)看一下他們的使用

3.1 屬性注入

3.1.1 原理

我們就在 UserController 里面調(diào)用 UserService , 也就是將 UserService 注入到 UserController 里面 , 咱們?cè)偃フ{(diào)用 UserController
我們先創(chuàng)建一個(gè)私有的屬性 , 這個(gè)屬性就是我們要注入的對(duì)象
然后在這個(gè)私有屬性上面加上 @Autowired 注解 (因?yàn)槲覀兿胍?userService 注入到 UserController 里面) , 他的意思是自動(dòng)裝配
JavaEE 突擊 5 - Spring 更簡(jiǎn)單的讀取和存儲(chǔ)對(duì)象(2),JavaEE 新手入門,spring,java-ee,java

為什么叫屬性注入呢 ?
其實(shí)是這樣的 , 我們把 @Autowired 注解去掉 , 其實(shí)就剩個(gè)私有的屬性 , 所以就叫屬性注入

接下來(lái)我們就可以調(diào)用 userService 的方法了

package com.ethan.controller;

import com.ethan.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    @Autowired
    private UserService userService;//想要注入的屬性
    public void doUserController() {
        System.out.println("do UserController");
        userService.doUserService();
    }
}

我們可以去啟動(dòng)類看看效果了

import com.ethan.controller.UserController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        // 1. 得到上下文對(duì)象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        // 2. 使用 getBean 得到 Bean 對(duì)象
        UserController userController = context.getBean("userController",UserController.class);

        // 3. 操作對(duì)象
        userController.doUserController();
    }
}

運(yùn)行查看結(jié)果

這就說(shuō)明我們?cè)?UserController 里面成功的把 UserService 注入成功
那么我們把 @Autowired 去掉呢

3.1.2 相關(guān)問(wèn)題

能在啟動(dòng)類里面調(diào)用 @Autowired 注解嗎

那么這里面有個(gè)問(wèn)題 , 我們的啟動(dòng)類里面還是 2.0 版本的方法 , 那么我們?yōu)槭裁床恢苯釉趩?dòng)類里面去添加 @Autowired 呢

import com.ethan.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;

public class App {
    @Autowired
    private UserService userService;

    public static void main(String[] args) {
        userService.doUserService();
    }
}

給大家分析一下原因
在 Java 里面 , 靜態(tài)類或者靜態(tài)方法優(yōu)先執(zhí)行

@Autowired 能使用多次嗎

我們目前是在 UserController 里面注入了 UserService , 那么我們?cè)?UserComponent 里面注入 UserController
UserComponent.java

package com.ethan.component;

import com.ethan.controller.UserController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UserComponent {
    @Autowired
    private UserController userController;

    public void doUserComponents() {
        System.out.println("do UserComponent");
        userController.doUserController();
    }
}

UserController.java

package com.ethan.controller;

import com.ethan.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    @Autowired
    private UserService userService;//想要注入的屬性
    public void doUserController() {
        System.out.println("do UserController");
        userService.doUserService();
    }
}

UserService.java

package com.ethan.service;

import org.springframework.stereotype.Service;

@Service
public class UserService {
    public void doUserService() {
        System.out.println("do UserService");
    }
}

啟動(dòng)類 :

import com.ethan.component.UserComponent;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        // 1. 得到上下文對(duì)象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        // 2. 使用 getBean 得到 Bean 對(duì)象
        UserComponent userComponent = context.getBean("userComponent",UserComponent.class);

        // 3. 操作對(duì)象
        userComponent.doUserComponents();
    }
}

打印了三句話 , 這就代表 @Autowired 可以多次使用

@Autowired 修飾的私有方法名字可以是其他的嗎

JavaEE 突擊 5 - Spring 更簡(jiǎn)單的讀取和存儲(chǔ)對(duì)象(2),JavaEE 新手入門,spring,java-ee,java
那么我們改一下屬性名試試看

那么為什么我們之前的名稱就有要求 , 這個(gè)就沒(méi)有呢
這個(gè)其實(shí)也是我們的一道面試題 : @Autowired 和 @Resource 有什么區(qū)別

這篇博客寫的非常細(xì)致
@Autowired 和 @Resource 有什么區(qū)別

我們看這張圖

我們的 @Autowired 是先通過(guò)類型去查找 , 比如我們這個(gè)例子

所以我們的 @Autowired 注解是先根據(jù)類型查詢 , 之后根據(jù)名稱查詢

3.1.3 屬性注入的優(yōu)點(diǎn)和缺點(diǎn)

優(yōu)點(diǎn) : 寫法簡(jiǎn)單
缺點(diǎn) :

最重要的缺點(diǎn)就是 IDEA 不推薦我們使用 ! 我們?cè)?社區(qū)版里面看不見(jiàn) , 去專業(yè)版里面給大家看一下 , 學(xué)生可以去學(xué)生認(rèn)證使用專業(yè)版

但是比較有意思的是 : Spring 官方放出來(lái)的代碼樣例 , 自己也這么用 , 因?yàn)樗娴暮?jiǎn)單易用
功能缺陷 : 不能注入一個(gè) final 修飾的屬性

這是因?yàn)?Java 語(yǔ)法規(guī)定 , final 修飾的變量必須要有初始值

可以這樣解決

  1.  final 修飾的變量我們可以初始化<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/28016775/1670681137539-c5f223e2-4dc7-4efa-9efb-24bc55c194b5.png#averageHue=%2363604a&clientId=u0b9d3e7e-71b6-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=817&id=ue4be36dd&name=image.png&originHeight=1021&originWidth=1920&originalType=binary&ratio=1&rotation=0&showTitle=false&size=177873&status=done&style=none&taskId=u664c54cb-a6eb-402e-bd6f-ef15bea1468&title=&width=1536)
  2.  在構(gòu)造方法里面賦值<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/28016775/1670681185645-0735b0a8-b853-4bed-ad3f-586d4f800017.png#averageHue=%2363614b&clientId=u0b9d3e7e-71b6-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=817&id=uc13f119a&name=image.png&originHeight=1021&originWidth=1920&originalType=binary&ratio=1&rotation=0&showTitle=false&size=191674&status=done&style=none&taskId=ua37fc8e3-d521-4ae8-b8a6-46fabf77725&title=&width=1536)

通用性問(wèn)題 : 屬性注入這種方式只適用于 IoC 容器(框架) -> 可移植性不高
設(shè)計(jì)原則問(wèn)題 : 因?yàn)檫@種方式寫法比較簡(jiǎn)單 , 所以就有可能造成濫用 , 更容易違背單一設(shè)計(jì)原則

單一設(shè)計(jì)原則 : 這個(gè)類設(shè)計(jì)出來(lái)只干一件事

3.2 Setter 注入

3.2.1 用法

還是先寫一個(gè)私有的屬性
然后去生成他的 set 方法

這樣我們的 setter 方法就構(gòu)造好了

接下來(lái) , 我們只需要在 setter 方法上面加上 @Autowired 注解就好了

package com.ethan.component;

import com.ethan.controller.UserController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UserComponent {
    private UserController userController;

    @Autowired
    public void setUserController(UserController userController) {
        this.userController = userController;
    }

    public void doUserComponents() {
        System.out.println("do UserComponent");
        userController.doUserController();
    }
}

我們?cè)囈幌驴刹豢梢?br>去啟動(dòng)類編寫代碼

import com.ethan.component.UserComponent;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        // 1. 得到上下文對(duì)象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        // 2. 使用 getBean 得到 Bean 對(duì)象
        UserComponent userComponent = context.getBean("userComponent",UserComponent.class);

        // 3. 操作對(duì)象
        userComponent.doUserComponents();
    }
}

運(yùn)行一下

3.2.2 優(yōu)點(diǎn)以及缺點(diǎn)

優(yōu)點(diǎn) : 符合單一設(shè)計(jì)原則 , 一個(gè) set 就是針對(duì)一個(gè)對(duì)象的
缺點(diǎn) :

不能注入不可變對(duì)象
注入對(duì)象可能會(huì)被改變
因?yàn)檫@個(gè) set 方法可以會(huì)被調(diào)用多次 , 就有可能造成被修改的風(fēng)險(xiǎn)

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

3.3.1 用法

還是先寫一個(gè)要注入的私有屬性 , 然后生成這個(gè)類的構(gòu)造方法

這樣構(gòu)造方法就自動(dòng)生成好了 , 構(gòu)造方法里面的參數(shù)就是要注入的屬性

最后在構(gòu)造方法上面添加 @Autowired 注解
UserComponent.java :

package com.ethan.component;

import com.ethan.controller.UserController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UserComponent {
    private UserController userController;

    @Autowired
    public UserComponent(UserController userController) {
        this.userController = userController;
    }

    public void doUserComponents() {
        System.out.println("do UserComponent");
        userController.doUserController();
    }
}

啟動(dòng)類

import com.ethan.component.UserComponent;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        // 1. 得到上下文對(duì)象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        // 2. 使用 getBean 得到 Bean 對(duì)象
        UserComponent userComponent = context.getBean("userComponent",UserComponent.class);

        // 3. 操作對(duì)象
        userComponent.doUserComponents();
    }
}

運(yùn)行一下 :

根據(jù)運(yùn)行結(jié)果 , 我們還可以看出 : 構(gòu)造方法也支持注入多個(gè)對(duì)象

3.3.2 注意事項(xiàng)

當(dāng)前類只有一個(gè)構(gòu)造方法的時(shí)候 , @Autowired 可以省略

有多個(gè)構(gòu)造方法的時(shí)候 , @Autowired 不可以省略

而且要關(guān)注的是 : 多個(gè)構(gòu)造方法的時(shí)候 , 只會(huì)運(yùn)行加了 @Autowired 的構(gòu)造方法

那么我們都加上 @Autowired 呢 ?

總結(jié)一下 : 在 Spring 中 , 一個(gè)類的構(gòu)造方法可以有多個(gè) , 但是只能有一個(gè)構(gòu)造方法上添加 @Autowired 注解 , 否則會(huì)報(bào)錯(cuò)

3.3.3 構(gòu)造方法注入的優(yōu)點(diǎn)

優(yōu)點(diǎn)1 : 可以注入 final 修飾的對(duì)象

原因 : 遵循了 Java 的規(guī)范
final 的用法 :

創(chuàng)建時(shí)直接賦值

在構(gòu)造方法中賦值

這樣就不難理解了 , 在 Java 里面就允許通過(guò)構(gòu)造方法給被 final 修飾的值進(jìn)行賦值 , 那么我們的 Spring 里面也可以通過(guò)構(gòu)造注入對(duì) final 修飾的值進(jìn)行賦值

那么我們就來(lái)實(shí)驗(yàn)一下 :

package com.ethan.component;

import com.ethan.controller.UserController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UserComponent {
    private final UserController userController;

    @Autowired
    public UserComponent(UserController userController) {
        this.userController = userController;
    }

    public void doUserComponents() {
        System.out.println("do UserComponent");
        userController.doUserController();
    }
}

優(yōu)點(diǎn)2 : 注入對(duì)象不能被修改 (構(gòu)造方法只會(huì)被執(zhí)行一次)
優(yōu)點(diǎn)3 : 要注入的對(duì)象在使用前一定會(huì)被完全初始化 , 因?yàn)樽⑷胍蕾囀窃陬惖臉?gòu)造方法中執(zhí)行的 , 而構(gòu)造方法是在類創(chuàng)建之初就會(huì)執(zhí)行的方法
優(yōu)點(diǎn)4 : 通用性更好 , 因?yàn)闃?gòu)造方法是 Java (JDK) 所支持的 , 而 JDK 我們可以認(rèn)為是 Spring 最低層的框架 , 所以更換任何的框架 , 它都是適用的

缺點(diǎn) : (優(yōu)點(diǎn)那么多 , 缺點(diǎn)就變得不是那么重要了)
構(gòu)造方法不滿足單一設(shè)計(jì)原則
JavaEE 突擊 5 - Spring 更簡(jiǎn)單的讀取和存儲(chǔ)對(duì)象(2),JavaEE 新手入門,spring,java-ee,java
Spring 4.2 推薦的注入用法是 Setter 注入 , Setter 更加符合單一設(shè)計(jì)原則
在 Spring 4.2 之后 , 推薦使用構(gòu)造方法注入的方式 . 官方給出的回復(fù)是如果你寫的代碼傳遞了太多的參數(shù) , 那么此時(shí)你要考慮一下你的代碼是否符合單一設(shè)計(jì)原則了

其實(shí)就是官方賴你了 , 你自己代碼寫的不好 , 還賴上我了 .

3.4 同一類型多個(gè)Bean報(bào)錯(cuò) -> @Resources

3.4.1 用法

這是另外一個(gè)注入關(guān)鍵字 , 是由 Java 官方提供給我們的注解
用法是跟我們 @Autowired 大致是一樣的
我們新創(chuàng)建一個(gè) resources 包 , 新建一個(gè) ReSourcesTest 來(lái)試驗(yàn)一下 @Resources
然后在 ReSourcesTest.java 編寫代碼

package com.ethan.reSources;

import com.ethan.component.UserComponent;
import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

@Controller
public class ReSourcesTest {
    @Resource
    private UserComponent userComponent;

    public void doResource() {
        System.out.println("do Resource");
        userComponent.doUserComponents();
    }
}

我們 Ctrl + 單擊一下 @Resources
JavaEE 突擊 5 - Spring 更簡(jiǎn)單的讀取和存儲(chǔ)對(duì)象(2),JavaEE 新手入門,spring,java-ee,java
發(fā)現(xiàn) @Resources 是來(lái)自于 Java 提供給我們的方法
那么我們就來(lái)試試 Java 給我們提供的辦法好不好使
啟動(dòng)類 :

import com.ethan.component.UserComponent;
import com.ethan.reSources.ReSourcesTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        // 1. 得到上下文對(duì)象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        // 2. 使用 getBean 得到 Bean 對(duì)象
        ReSourcesTest reSourcesTest = context.getBean("reSourcesTest",ReSourcesTest.class);
        // 3. 操作對(duì)象
        reSourcesTest.doResource();
    }
}

那么屬性注入可以 , Setter 注入以及構(gòu)造方法注入呢 ?
Setter 注入可以

package com.ethan.reSources;

import com.ethan.component.UserComponent;
import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

@Controller
public class ReSourcesTest {
    private UserComponent userComponent;
    @Resource
    public void setUserComponent(UserComponent userComponent) {
        this.userComponent = userComponent;
    }

    public void doResource() {
        System.out.println("do Resource");
        userComponent.doUserComponents();
    }
}

但是構(gòu)造方法注入不可以 !

package com.ethan.reSources;

import com.ethan.component.UserComponent;
import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

@Controller
public class ReSourcesTest {
    private UserComponent userComponent;
    
    @Resource
    public ReSourcesTest(UserComponent userComponent) {
        this.userComponent = userComponent;
    }
    
    public void doResource() {
        System.out.println("do Resource");
        userComponent.doUserComponents();
    }
}

強(qiáng)行執(zhí)行仍然會(huì)報(bào)錯(cuò)的

3.4.2 @Resources 不能在構(gòu)造方法上使用

那么既然 @Autowired 能用 , 我們?yōu)槭裁催€要介紹 @Resources 呢 ?
功能 : 實(shí)現(xiàn)對(duì)象注入

使用1 : 實(shí)現(xiàn)屬性注入
使用2 : 實(shí)現(xiàn) Setter 注入
**@Resource 注解不能使用在構(gòu)造方法的實(shí)現(xiàn)上 **

原因是 : Java 實(shí)現(xiàn)的時(shí)候 , 構(gòu)造方法是先執(zhí)行的 , 但是這個(gè)注解是在構(gòu)造方法之后執(zhí)行的 , 所以目前是不支持這種實(shí)現(xiàn)的

3.4.3 @Resources 參數(shù) VS @Autowired 參數(shù)

我們直接看源碼
先看 @Resources
Ctrl + 單擊 @Resources
JavaEE 突擊 5 - Spring 更簡(jiǎn)單的讀取和存儲(chǔ)對(duì)象(2),JavaEE 新手入門,spring,java-ee,java
再看 @Autowired

他們兩個(gè)支持的參數(shù)完全不同 , 就這么一看 , 還是感覺(jué) @Resources 能用的方法多
給大家舉個(gè)栗子 :
當(dāng)使用 Bean 注解返回兩個(gè)類型相同的 Bean 的時(shí)候 , 默認(rèn)使用注入的方式得到對(duì)象就會(huì)報(bào)錯(cuò) , 這么說(shuō)大家有點(diǎn)亂 , 用代碼來(lái)看一下
在之前的 UserBeans 里面有兩個(gè)方法 , 他們的返回值相同 , 都是 User
UserBean.java :

package com.ethan.userbean;

import com.ethan.model.User;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Controller;

@Controller
public class UserBean {
    @Bean("anlingrong")
    public User func() {
        // 構(gòu)建測(cè)試數(shù)據(jù)
        User user = new User();
        user.setName("安陵容");
        user.setAge(18);
        user.setId(1);
        return user;
    }

    @Bean("shenmeizhuang")
    public User func2() {
        User user = new User();
        user.setName("沈眉莊");
        user.setAge(20);
        user.setId(2);
        return user;
    }
}

然后新建一個(gè)類 UserBean2 , 先試驗(yàn)一下 @Autowired

package com.ethan.userbean;

import com.ethan.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserBean2 {
    @Autowired
    private User user;

    public void method() {
        System.out.println(user.getName());
    }
}

然后設(shè)置啟動(dòng)類

import com.ethan.component.UserComponent;
import com.ethan.reSources.ReSourcesTest;
import com.ethan.userbean.UserBean2;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        // 1. 得到上下文對(duì)象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        // 2. 使用 getBean 得到 Bean 對(duì)象
        UserBean2 userBean2 = context.getBean("userBean2",UserBean2.class);
        // 3. 操作對(duì)象
        userBean2.method();
    }
}

運(yùn)行就報(bào)錯(cuò)了

@Autowired 是先按照類型去找 , 如果找到了 , 但是找到了不止一個(gè)的話 , 就需要按名字去查詢 .
如果還沒(méi)找到 , 那就報(bào)錯(cuò) .
那么我們這個(gè)例子 , 類型找到了 , 這種類型對(duì)應(yīng)了兩個(gè) Bean 對(duì)象 , 那么按名字找 , 沒(méi)找到名字叫做 user 的方法名 , 就報(bào)錯(cuò)了.
我們也可以演示一下按名字能找到的場(chǎng)景

那么其實(shí)我們可以使用 @Resources 來(lái)避免這種情況
@Resources 就是先按照名字來(lái)找

package com.ethan.userbean;

import com.ethan.model.User;
import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

@Controller
public class UserBean2 {
    @Resource(name="anlingrong")
    private User user;

    public void method() {
        System.out.println(user.getName());
    }
}

因?yàn)?@Resources 是先找名字再找類型 , 所以我們可以指定 @Resources 參數(shù)為我們想要的 Bean 對(duì)象的名稱
那么感覺(jué) @Resources 挺好用的啊 , 但是不要忘了 , @Resources 是不支持構(gòu)造方法注入的 , 而我們的 Spring 還推薦使用構(gòu)造方法注入 , 那怎么辦呢 ?
那就需要請(qǐng)出我們另外一個(gè)注解了 @Qualifier , 翻譯成中文就是篩選的意思 .
我們需要結(jié)合 @Qualifier 和 @Autowired 來(lái)使用了
@Qualifier里面有個(gè) value 參數(shù) , 填寫我們想要獲取的 Bean 對(duì)象即可
UserController3.java

package com.ethan.userbean;

import com.ethan.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

@Controller
public class UserBean2 {
    @Autowired
    @Qualifier(value="shenmeizhuang")
    private User user;

    public void method() {
        System.out.println(user.getName());
    }
}

運(yùn)行一下

3.5 綜合練習(xí)

在 Spring 項(xiàng)目中 , 通過(guò) main 方法獲取到 Controller 類 , 調(diào)用 Controller 里面通過(guò)注入的方式調(diào)用 Service 類 , Service 再通過(guò)注入的方式獲取到 Repository 類 , Repository 類里面有一個(gè)方法構(gòu)建一個(gè) User 對(duì)象 , 返回給 main 方法 . Repository 無(wú)需連接數(shù)據(jù)庫(kù) , 使用偽代碼即可 .
解釋一下 : 首先 , 創(chuàng)建一個(gè) Spring 項(xiàng)目 , 然后創(chuàng)建三個(gè)類 Controller類、Service類、Repository類 , 然后在 Controller類里面注入 Service 對(duì)象 , 在 Service類里面注入 Repository類 , 然后在 Repository類里面創(chuàng)建一個(gè) User 對(duì)象(因?yàn)槲覀冞€沒(méi)學(xué)連接數(shù)據(jù)庫(kù) , 所以就先通過(guò)這種方式湊活用) , 最后寫一個(gè)啟動(dòng)類 , 調(diào)用 Controller 就可以獲取到其他相關(guān)信息

四 . 總結(jié)

將對(duì)象存儲(chǔ)到 Spring 中 :
1. 使用類注解 :
  1. @Controller
  2. @Service
  3. @Repository
  4. @Configuration
  5. @Component
2. 使用方法注解 : @Bean (注意 : 必須配合類注解一起使用)
Bean 的命名規(guī)則
1. 首字母大寫 , 第二個(gè)字母不大寫 : 首字母小寫獲取 Bean
2. 首字母第二個(gè)字母都是大寫 : 使用原類名獲取 Bean
從 Spring 中獲取對(duì)象
1. 屬性注入
2. Setter 注入
3. 構(gòu)造方法注入(Spring 官方推薦)
注入的關(guān)鍵字 :
1. @Autowired
2. @Resource
3. 區(qū)別 :
  1. 出身不同 : @Autowired 來(lái)自于 Spring , @Resource 來(lái)自于 JDK
  2. 使用時(shí)可設(shè)置的參數(shù)不同
解決同一類型多個(gè) Bean 的報(bào)錯(cuò)
1. 使用 @Resource(name=“”)
2. @Autowired 搭配 @Qualifier(“”) 使用

到此 , 這篇文章就已經(jīng)結(jié)束了 , 歡迎大家的閱讀 , 有問(wèn)題及時(shí)私信我 , 歡迎提供錯(cuò)誤
點(diǎn)擊此鏈接獲得更加好的閱讀體驗(yàn)
JavaEE 突擊 5 - Spring 更簡(jiǎn)單的讀取和存儲(chǔ)對(duì)象(2),JavaEE 新手入門,spring,java-ee,java

點(diǎn)擊即可跳轉(zhuǎn)到我的小秘密文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-827791.html

到了這里，關(guān)于JavaEE 突擊 5 - Spring 更簡(jiǎn)單的讀取和存儲(chǔ)對(duì)象(2)的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！