現(xiàn)在面試，基本上都是面試造火箭，工作擰螺絲。而且是喜歡問一些 spring 相關(guān)的知識點(diǎn)，比如 @autowired 和 @resource 之間的區(qū)別。魔高一丈，道高一尺。很快不少程序員學(xué)會了背誦面試題，那我反過來問“spring 中的注解 @autowired是如何實(shí)現(xiàn)的？”，“說說 @autowired 的實(shí)現(xiàn)原理？”等等，背誦面試題的就露餡了。基于此，今天我們來說一說 @autowired 背后的故事！
前言
使用 spring 開發(fā)時，進(jìn)行配置主要有兩種方式，一是 xml 的方式，二是 java config 的方式。spring 技術(shù)自身也在不斷的發(fā)展和改變，從當(dāng)前 springboot 的火熱程度來看，java config 的應(yīng)用是越來越廣泛了，在使用 java config 的過程當(dāng)中，我們不可避免的會有各種各樣的注解打交道，其中，我們使用最多的注解應(yīng)該就是 @autowired 注解了。這個注解的功能就是為我們注入一個定義好的 bean。那么，這個注解除了我們常用的屬性注入方式之外還有哪些使用方式呢？它在代碼層面又是怎么實(shí)現(xiàn)的呢？這是本篇文章著重想討論的問題。
@autowired 注解用法
在分析這個注解的實(shí)現(xiàn)原理之前，我們不妨先來回顧一下 @autowired 注解的用法。
將 @autowired 注解應(yīng)用于構(gòu)造函數(shù)，如以下示例所示
|
1
2
3
4
5
6
7
8
|
`public class movierecommender {` `private final customerpreferencedao customerpreferencedao;` `@autowired` `public movierecommender(customerpreferencedao customerpreferencedao) {` `this.customerpreferencedao = customerpreferencedao;` `}` `// ...``}` |
將 @autowired 注釋應(yīng)用于 setter 方法
|
1
2
3
4
5
6
7
8
|
`public class simplemovielister {` `private moviefinder moviefinder;` `@autowired` `public void setmoviefinder(moviefinder moviefinder) {` `this.moviefinder = moviefinder;` `}` `// ...``}` |
將 @autowired 注釋應(yīng)用于具有任意名稱和多個參數(shù)的方法
|
1
2
3
4
5
6
7
8
9
10
11
|
`public class movierecommender {` `private moviecatalog moviecatalog;` `private customerpreferencedao customerpreferencedao;` `@autowired` `public void prepare(moviecatalog moviecatalog,` `customerpreferencedao customerpreferencedao) {` `this.moviecatalog = moviecatalog;` `this.customerpreferencedao = customerpreferencedao;` `}` `// ...``}` |
您也可以將 @autowired 應(yīng)用于字段，或者將其與構(gòu)造函數(shù)混合，如以下示例所示
|
1
2
3
4
5
6
7
8
9
10
|
`public class movierecommender {` `private final customerpreferencedao customerpreferencedao;` `@autowired` `private moviecatalog moviecatalog;` `@autowired` `public movierecommender(customerpreferencedao customerpreferencedao) {` `this.customerpreferencedao = customerpreferencedao;` `}` `// ...``}` |
直接應(yīng)用于字段是我們使用的最多的一種方式，但是使用構(gòu)造方法注入從代碼層面卻是更加好的，具體原因我就不細(xì)說了，有不懂的可以留言區(qū)評論。除此之外，還有以下不太常見的幾種方式。
將 @autowired 注釋添加到需要該類型數(shù)組的字段或方法，則 spring 會從applicationcontext 中搜尋符合指定類型的所有 bean，如以下示例所示：
|
1
2
3
4
5
|
`public class movierecommender {` `@autowired` `private moviecatalog[] moviecatalogs;` `// ...``}` |
數(shù)組可以，我們可以馬上舉一反三，那容器也可以嗎，答案是肯定的，下面是 set 以及 map 的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
`public class movierecommender {` `private set<moviecatalog> moviecatalogs;` `private map<string, moviecatalog> moviecatalogs;` `@autowired` `public void setmoviecatalogs(set<moviecatalog> moviecatalogs) {` `this.moviecatalogs = moviecatalogs;` `}` `@autowired` `public void setmoviecatalogs(map<string, moviecatalog> moviecatalogs) {` `this.moviecatalogs = moviecatalogs;` `}` `// ...``}` |
以上就是 @autowired 注解的主要使用方式，經(jīng)常使用 spring 的話應(yīng)該對其中常用的幾種不會感到陌生。
@autowired 注解的作用到底是什么
@autowired 這個注解我們經(jīng)常在使用，現(xiàn)在，我想問的是，它的作用到底是什么呢?
首先，我們從所屬范圍來看，事實(shí)上這個注解是屬于 spring 的容器配置的一個注解，與它同屬容器配置的注解還有：@required, @primary, @qualifier 等等。因此 @autowired 注解是一個用于容器(container)配置的注解。
其次，我們可以直接從字面意思來看，@autowired 注解來源于英文單詞 autowire，這個單詞的意思是自動裝配的意思。自動裝配又是什么意思？這個詞語本來的意思是指的一些工業(yè)上的用機(jī)器代替人口，自動將一些需要完成的組裝任務(wù)，或者別的一些任務(wù)完成。而在 spring 的世界當(dāng)中，自動裝配指的就是使用將 spring 容器中的 bean 自動的和我們需要這個 bean 的類組裝在一起。
因此，筆者個人對這個注解的作用下的定義就是：將 spring 容器中的 bean 自動的和我們需要這個 bean 的類組裝在一起協(xié)同使用。
接下來，我們就來看一下這個注解背后到底做了些什么工作。
@autowired 注解是如何實(shí)現(xiàn)的
事實(shí)上，要回答這個問題必須先弄明白的是 java 是如何支持注解這樣一個功能的。
java 的注解實(shí)現(xiàn)的核心技術(shù)是反射，讓我們通過一些例子以及自己實(shí)現(xiàn)一個注解來理解它工作的原理。
例子注解 @override
@override 注解的定義如下:
|
1
2
3
4
|
`@target(elementtype.method)``@retention(retentionpolicy.source)``public @interface override {``}` |
@override 注解使用 java 官方提供的注解，它的定義里面并沒有任何的實(shí)現(xiàn)邏輯。注意，所有的注解幾乎都是這樣的，「注解只能是被看作元數(shù)據(jù)，它不包含任何業(yè)務(wù)邏輯」。「注解更像是一個標(biāo)簽，一個聲明，表面被注釋的這個地方，將具有某種特定的邏輯」。
那么，問題接踵而至，注解本身不包含任何邏輯，那么注解的功能是如何實(shí)現(xiàn)的呢？答案必然是別的某個地方對這個注解做了實(shí)現(xiàn)。以 @override 注解為例，他的功能是重寫一個方法，而他的實(shí)現(xiàn)者就是 jvm，java 虛擬機(jī)，java 虛擬機(jī)在字節(jié)碼層面實(shí)現(xiàn)了這個功能。
但是對于開發(fā)人員，虛擬機(jī)的實(shí)現(xiàn)是無法控制的東西，也不能用于自定義注解。所以，如果是我們自己想定義一個獨(dú)一無二的注解的話，則我們需要自己為注解寫一個實(shí)現(xiàn)邏輯，「換言之，我們需要實(shí)現(xiàn)自己注解特定邏輯的功能」。
自己實(shí)現(xiàn)一個注解
在自己寫注解之前我們有一些基礎(chǔ)知識需要掌握，那就是我們寫注解這個功能首先是需要 java 支持的，java 在 jdk5 當(dāng)中支持了這一功能，「并且在 java.lang.annotation 包中提供了四個注解，僅用于編寫注解時使用」，他們是：
注解
作用
「@documented」
表明是否在java doc中添加annotation
「@retention」
定義注釋應(yīng)保留多長時間，即有效周期。有以下幾種策略：
「retentionpolicy.source」 - 在編譯期間丟棄。編譯完成后，這些注釋沒有任何意義，因此它們不會寫入字節(jié)碼。示例@override，@ suppresswarnings
「retentionpolicy.class 」- 在類加載期間丟棄。在進(jìn)行字節(jié)碼級后處理時很有用。有點(diǎn)令人驚訝的是，這是默認(rèn)值。
「retentionpolicy.runtime」 - 不要丟棄。注釋應(yīng)該可以在運(yùn)行時進(jìn)行反射。這是我們通常用于自定義注釋的內(nèi)容。
「@target」
指定可以放置注解的位置。如果不指定，則可以將注解放在任何位置。若我們只想要其中幾個，則需要定義對應(yīng)的幾個。
下面是這8個屬性:
elementtype.type（類，接口，枚舉）
elementtype.field（實(shí)例變量）
elementtype.method
elementtype.parameter
elementtype.constructor
elementtype.local_variable
elementtype.annotation_type（在另一個注釋上）
elementtype.package（記住package-info.java）
「@inherited」
控制注解是否對子類產(chǎn)生影響。
下面我們開始自己實(shí)現(xiàn)一個注解，注解僅支持 primitives，string和 enumerations 這三種類型。注解的所有屬性都定義為方法，也可以提供默認(rèn)值。我們先實(shí)現(xiàn)一個最簡單的注解。
|
1
2
3
4
5
6
7
8
9
|
`import java.lang.annotation.elementtype;``import java.lang.annotation.retention;``import java.lang.annotation.retentionpolicy;``import java.lang.annotation.target;``@target(elementtype.method)``@retention(retentionpolicy.runtime)``public @interface simpleannotation {` `string value();``}` |
上面這個注釋里面只定義了一個字符傳，它的目標(biāo)注釋對象是方法，保留策略是在運(yùn)行期間。下面我們定義一個方法來使用這個注解：
|
1
2
3
4
5
6
|
`public class useannotation {` `@simpleannotation("teststringvalue")` `public void testmethod(){` `//do something here` `}``}` |
我們在這里使用了這個注解，并把字符串賦值為：teststringvalue，到這里，定義一個注解并使用它，我們就已經(jīng)全部完成。
簡單的不敢相信。但是，細(xì)心一想的話，我們雖然寫了一個注解也用了它，可是它并沒有產(chǎn)生任何作用啊。也沒有對我們這里方法產(chǎn)生任何效果啊。是的現(xiàn)在確實(shí)是這樣的，原因在于我們前面提到的一點(diǎn)，我們還沒有為這個注解實(shí)現(xiàn)它的邏輯，現(xiàn)在我們就來為這個注解實(shí)現(xiàn)邏輯。
應(yīng)該怎么做呢？我們不妨自己來想一想。首先，我想給標(biāo)注了這個注解的方法或字段實(shí)現(xiàn)功能，我們必須得知道，到底有哪些方法，哪些字段使用了這個注解吧，因此，這里我們很容易想到，這里應(yīng)該會用到反射。其次，利用反射，我們利用反射拿到這樣目標(biāo)之后，得為他實(shí)現(xiàn)一個邏輯，這個邏輯是這些方法本身邏輯之外的邏輯，這又讓我們想起了代理，aop 等知識，我們相當(dāng)于就是在為這些方法做一個增強(qiáng)。事實(shí)上的實(shí)現(xiàn)主借的邏輯也大概就是這個思路。梳理一下大致步驟如下:
- 利用反射機(jī)制獲取一個類的 class 對象
- 通過這個 class 對象可以去獲取他的每一個方法 method，或字段 field 等等
- method，field 等類提供了類似于 getannotation 的方法來獲取這個一個字段的所有注解
- 拿到注解之后，我們可以判斷這個注解是否是我們要實(shí)現(xiàn)的注解，如果是則實(shí)現(xiàn)注解邏輯
現(xiàn)在我們來實(shí)現(xiàn)一下這個邏輯，代碼如下:
|
1
2
3
4
5
6
7
8
9
10
11
|
`private static void annotationlogic() {` `class useannotationclass = useannotation.class;` `for(method method : useannotationclass.getmethods()) {` `simpleannotation simpleannotation = (simpleannotation)method.getannotation(simpleannotation.class);` `if(simpleannotation != null) {` `system.out.println(" method name : " + method.getname());` `system.out.println(" value : " + simpleannotation.value());` `system.out.println(" --------------------------- ");` `}` `}``}` |
在這里我們實(shí)現(xiàn)的邏輯就是打印幾句話。從上面的實(shí)現(xiàn)邏輯我們不能發(fā)現(xiàn)，借助于 java 的反射我們可以直接拿到一個類里所有的方法，然后再拿到方法上的注解，當(dāng)然，我們也可以拿到字段上的注解。借助于反射我們可以拿到幾乎任何屬于一個類的東西。
一個簡單的注解我們就實(shí)現(xiàn)完了。現(xiàn)在我們再回過頭來，看一下 @autowired 注解是如何實(shí)現(xiàn)的。
@autowired 注解實(shí)現(xiàn)邏輯分析
知道了上面的知識，我們不難想到，上面的注解雖然簡單，但是 @autowired 和他最大的區(qū)別應(yīng)該僅僅在于注解的實(shí)現(xiàn)邏輯，其他利用反射獲取注解等等步驟應(yīng)該都是一致的。先來看一下 @autowired 這個注解在 spring 的源代碼里的定義是怎樣的，如下所示：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
`package org.springframework.beans.factory.annotation;``import java.lang.annotation.documented;``import java.lang.annotation.elementtype;``import java.lang.annotation.retention;``import java.lang.annotation.retentionpolicy;``import java.lang.annotation.target;``@target({elementtype.constructor, elementtype.method, elementtype.parameter, elementtype.field, elementtype.annotation_type})``@retention(retentionpolicy.runtime)``@documented``public @interface autowired {` `boolean required() default true;``}` |
閱讀代碼我們可以看到，autowired 注解可以應(yīng)用在構(gòu)造方法，普通方法，參數(shù)，字段，以及注解這五種類型的地方，它的保留策略是在運(yùn)行時。下面，我們不多說直接來看 spring 對這個注解進(jìn)行的邏輯實(shí)現(xiàn).
在 spring 源代碼當(dāng)中，autowired 注解位于包 org.springframework.beans.factory.annotation 之中，該包的內(nèi)容如下：
經(jīng)過分析，不難發(fā)現(xiàn) spring 對 autowire 注解的實(shí)現(xiàn)邏輯位于類：autowiredannotationbeanpostprocessor 之中，已在上圖標(biāo)紅。其中的核心處理代碼如下:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
`private injectionmetadata buildautowiringmetadata(final class<?> clazz) {` `linkedlist<injectionmetadata.injectedelement> elements = new linkedlist<>();` `class<?> targetclass = clazz;//需要處理的目標(biāo)類` `do {` `final linkedlist<injectionmetadata.injectedelement> currelements = new linkedlist<>();` `/*通過反射獲取該類所有的字段，并遍歷每一個字段，并通過方法findautowiredannotation遍歷每一個字段的所用注解，并如果用autowired修飾了，則返回auotowired相關(guān)屬性*/` `reflectionutils.dowithlocalfields(targetclass, field -> {` `annotationattributes ann = findautowiredannotation(field);` `if (ann != null) {//校驗(yàn)autowired注解是否用在了static方法上` `if (modifier.isstatic(field.getmodifiers())) {` `if (logger.iswarnenabled()) {` `logger.warn("autowired annotation is not supported on static fields: " + field);` `}` `return;` `}//判斷是否指定了required` `boolean required = determinerequiredstatus(ann);` `currelements.add(new autowiredfieldelement(field, required));` `}` `});` `//和上面一樣的邏輯，但是是通過反射處理類的method` `reflectionutils.dowithlocalmethods(targetclass, method -> {` `method bridgedmethod = bridgemethodresolver.findbridgedmethod(method);` `if (!bridgemethodresolver.isvisibilitybridgemethodpair(method, bridgedmethod)) {` `return;` `}` `annotationattributes ann = findautowiredannotation(bridgedmethod);` `if (ann != null && method.equals(classutils.getmostspecificmethod(method, clazz))) {` `if (modifier.isstatic(method.getmodifiers())) {` `if (logger.iswarnenabled()) {` `logger.warn("autowired annotation is not supported on static methods: " + method);` `}` `return;` `}` `if (method.getparametercount() == 0) {` `if (logger.iswarnenabled()) {` `logger.warn("autowired annotation should only be used on methods with parameters: " +` `method);` `}` `}` `boolean required = determinerequiredstatus(ann);` `propertydescriptor pd = beanutils.findpropertyformethod(bridgedmethod, clazz);` `currelements.add(new autowiredmethodelement(method, required, pd));` `}` `});` `//用@autowired修飾的注解可能不止一個，因此都加在currelements這個容器里面，一起處理` `elements.addall(0, currelements);` `targetclass = targetclass.getsuperclass();` `}` `while (targetclass != null && targetclass != object.class);` `return new injectionmetadata(clazz, elements);` `}` |
博主在源代碼里加了注釋，結(jié)合注釋就能看懂它做的事情了，最后這個方法返回的就是包含所有帶有 autowire 注解修飾的一個 injectionmetadata 集合。這個類由兩部分組成:
|
1
2
3
4
|
`public injectionmetadata(class<?> targetclass, collection<injectedelement> elements) {` `this.targetclass = targetclass;` `this.injectedelements = elements;``}` |
一是我們處理的目標(biāo)類，二就是上述方法獲取到的所以 elements 集合。
有了目標(biāo)類，與所有需要注入的元素集合之后，我們就可以實(shí)現(xiàn) autowired 的依賴注入邏輯了，實(shí)現(xiàn)的方法如下:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
`@override``public propertyvalues postprocesspropertyvalues(` `propertyvalues pvs, propertydescriptor[] pds, object bean, string beanname) throws beancreationexception {` `injectionmetadata metadata = findautowiringmetadata(beanname, bean.getclass(), pvs);` `try {` `metadata.inject(bean, beanname, pvs);` `}` `catch (beancreationexception ex) {` `throw ex;` `}` `catch (throwable ex) {` `throw new beancreationexception(beanname, "injection of autowired dependencies failed", ex);` `}` `return pvs;``}` |
它調(diào)用的方法是 injectionmetadata 中定義的 inject 方法，如下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
`public void inject(object target, @nullable string beanname, @nullable propertyvalues pvs) throws throwable {` `collection<injectedelement> checkedelements = this.checkedelements;` `collection<injectedelement> elementstoiterate =` `(checkedelements != null ? checkedelements : this.injectedelements);` `if (!elementstoiterate.isempty()) {` `for (injectedelement element : elementstoiterate) {` `if (logger.istraceenabled()) {` `logger.trace("processing injected element of bean '" + beanname + "': " + element);` `}` `element.inject(target, beanname, pvs);` `}` `}``}` |
其邏輯就是遍歷，然后調(diào)用 inject 方法，inject 方法其實(shí)現(xiàn)邏輯如下:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
`/**` `* either this or {@link #getresourcetoinject} needs to be overridden.` `*/``protected void inject(object target, @nullable string requestingbeanname, @nullable propertyvalues pvs)` `throws throwable {` `if (this.isfield) {` `field field = (field) this.member;` `reflectionutils.makeaccessible(field);` `field.set(target, getresourcetoinject(target, requestingbeanname));` `}` `else {` `if (checkpropertyskipping(pvs)) {` `return;` `}` `try {` `method method = (method) this.member;` `reflectionutils.makeaccessible(method);` `method.invoke(target, getresourcetoinject(target, requestingbeanname));` `}` `catch (invocationtargetexception ex) {` `throw ex.gettargetexception();` `}` `}``}` |
在這里的代碼當(dāng)中我們也可以看到，是 inject 也使用了反射技術(shù)并且依然是分成字段和方法去處理的。在代碼里面也調(diào)用了 makeaccessible 這樣的可以稱之為暴力破解的方法，但是反射技術(shù)本就是為框架等用途設(shè)計的，這也無可厚非。
對于字段的話，本質(zhì)上就是去 set 這個字段的值，即對對象進(jìn)行實(shí)例化和賦值，例如下面代碼:
|
1
2
|
`@autowired``objecttest objecttest;` |
那么在這里實(shí)現(xiàn)的就相當(dāng)于給這個 objectest 引用賦值了。
對于方法的話，本質(zhì)就是去調(diào)用這個方法，因此這里調(diào)用的是 method.invoke。
getresourcetoinject 方法的參數(shù)就是要注入的 bean 的名字，這個方法的功能就是根據(jù)這個 bean 的名字去拿到它。
以上，就是 @autowire 注解實(shí)現(xiàn)邏輯的全部分析。結(jié)合源代碼再看一遍的話，會更加清楚一點(diǎn)。下面是 spring 容器如何實(shí)現(xiàn) @autowired 自動注入的過程的圖:
總結(jié)起來一句話：使用 @autowired 注入的 bean 對于目標(biāo)類來說，從代碼結(jié)構(gòu)上來講也就是一個普通的成員變量，@autowired 和 spring 一起工作，通過反射為這個成員變量賦值，也就是將其賦為期望的類實(shí)例。
衍生問題
注解的有效周期是什么？
各種注釋之間的第一個主要區(qū)別是，它們是在編譯時使用，然后被丟棄（如@override），還是被放在編譯的類文件中，并在運(yùn)行時可用（如 spring 的@component）。這是由注釋的“@retention”策略決定的。如果您正在編寫自己的注釋，則需要決定該注釋在運(yùn)行時（可能用于自動配置）還是僅在編譯時（用于檢查或代碼生成）有用。
當(dāng)用注釋編譯代碼時，編譯器看到注釋就像看到源元素上的其他修飾符一樣，比如訪問修飾符（public / private）。當(dāng)遇到注釋時，它運(yùn)行一個注釋處理器，就像一個插件類，表示對特定的注釋感興趣。注釋處理器通常使用反射api來檢查正在編譯的元素，并且可以簡單地對它們執(zhí)行檢查、修改它們或生成要編譯的新代碼。@override 是一個示例；它使用反射 api 來確保能夠在其中一個超類中找到方法簽名的匹配，如果不能，則使用 @override 會導(dǎo)致編譯錯誤。
注入的 bean 和用它的 bean 的關(guān)系是如何維護(hù)的？
無論以何種方式注入，注入的 bean 就相當(dāng)于類中的一個普通對象應(yīng)用，這是它的實(shí)例化是 spring 去容器中找符合的 bean 進(jìn)行實(shí)例化，并注入到類當(dāng)中的。他們之間的關(guān)系就是普通的一個對象持有另一個對象引用的關(guān)系。只是這些對象都是 spring 當(dāng)中的 bean 而已。
為什么注入的 bean 不能被定義為 static 的？
從設(shè)計的角度來說 ，使用靜態(tài)字段會鼓勵使用靜態(tài)方法。靜態(tài)方法是 evil 的。依賴注入的主要目的是讓容器為您創(chuàng)建對象并進(jìn)行連接。而且，它使測試更加容易。
一旦開始使用靜態(tài)方法，您就不再需要創(chuàng)建對象的實(shí)例，并且測試變得更加困難。同樣，您不能創(chuàng)建給定類的多個實(shí)例，每個實(shí)例都注入不同的依賴項(xiàng)（因?yàn)樵撟侄问请[式共享的，并且會創(chuàng)建全局狀態(tài)）。
靜態(tài)變量不是 object 的屬性，而是 class 的屬性。spring 的 autowire 是在對象上完成的，這樣使得設(shè)計很干凈。 在 spring 當(dāng)中我們也可以將 bean 對象定義為單例，這樣就能從功能上實(shí)現(xiàn)與靜態(tài)定義相同的目的。
但是從純粹技術(shù)的層面，我們可以這樣做：
將 @autowired 可以與 setter 方法一起使用，然后可以讓 setter 修改靜態(tài)字段的值。但是這種做法非常不推薦。
到此這篇關(guān)于spring中的注解@autowired實(shí)現(xiàn)過程全解的文章就介紹到這了,更多相關(guān)spring注解@autowired內(nèi)容請搜索服務(wù)器之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持服務(wù)器之家！
到此這篇關(guān)于spring中的注解@autowired實(shí)現(xiàn)過程全解(@autowired 背后的故事)的文章就介紹到這了,更多相關(guān)spring注解@autowired內(nèi)容請搜索服務(wù)器之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持服務(wù)器之家！
原文鏈接：https://blog.csdn.net/hnjsjsac/article/details/118540683
