Warum verbieten große Unternehmen die Verwendung der @Autowired-Annotation in Spring Boot-Projekten?

1. Beschreibung

Das Unternehmen hat kürzlich das Framework vom Original aktualisiert <span style="outline: 0px;Schriftgröße: 16px;Sichtbarkeit: sichtbar;">Spring Framerwork 3.0 <code style='margin-right: 2px;margin-left: 2px;padding: 2px 4px;outline: 0px;letter-spacing: 0.034em;font-size: 14px;border-radius: 4px;background-color: rgba(27, 31, 35, 0.05);font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(239, 112, 96);visibility: visible;'><span style="outline: 0px;font-size: 16px;visibility: visible;">spring framerwork 3.0</span>升级到<span style="outline: 0px;font-size: 16px;visibility: visible;">5.0</span>Upgrade auf <span style="outline: 0px;font-size: 16px;sichtbarkeit: sichtbar;">5.0</span>, und dann, als ich den Code schrieb Ich habe plötzlich herausgefunden, dass die @Autowired

Ich habe die relevanten Dokumente überprüft und festgestellt, dass diese Eingabeaufforderung nach <code style="outline: 0px;visibility: visible;"><span style="outline: 0px;font-size: 16px;visibility: visible;">spring framerwork 4.0</span>以后开始出现的，spring 4.0开始就不推荐使用属性注入，改为推荐构造器注入和setter注入。

下面将展示了spring框架可以使用的不同类型的依赖注入，以及每种依赖注入的适用情况。

2、依赖注入的类型

尽管针对<span style="outline: 0px;font-size: 16px;">spring framerwork 5.1.3</span>spring Framerwork 4.0 angezeigt wurde, aber danach nicht mehr angezeigt wird Spring 4.0 wird empfohlen, Eigenschaftsinjektion zu verwenden, und stattdessen werden Konstruktorinjektion und Setterinjektion empfohlen.

2. Arten der Abhängigkeitsinjektion🎜🎜

🎜spring Framerwork 5.1.3🎜🎜 nur zwei Haupttypen der Abhängigkeitsinjektion definiert, gibt es tatsächlich drei;🎜 🎜</p> <ul class="list-paddingleft-1" data-tool="mdnice编辑器" style='margin-top: 8px;margin-bottom: 8px;padding-left: 25px;outline: 0px;font-family: system-ui, -apple-system, BlinkMacSystemFont, "Helvetica Neue", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei UI", "Microsoft YaHei", Arial, sans-serif;letter-spacing: 0.544px;white-space: normal;background-color: rgb(255, 255, 255);'> <li style="outline: 0px;font-size: 16px;"><section style="margin-top: 5px;margin-bottom: 5px;outline: 0px;line-height: 26px;color: rgb(1, 1, 1);"><span style="outline: 0px;">Konstruktorbasierte Abhängigkeitsinjektion</span></section></li> <li style="outline: 0px;font-size: 16px;"><section style="margin-top: 5px;margin-bottom: 5px;outline: 0px;line-height: 26px;color: rgb(1, 1, 1);"><span style="outline: 0px;">Setterbasierte Abhängigkeitsinjektion</span></section></li> <li style="outline: 0px;font-size: 16px;"><section style="margin-top: 5px;margin-bottom: 5px;outline: 0px;line-height: 26px;color: rgb(1, 1, 1);"><span style="outline: 0px;">Feldbasierte Abhängigkeitsinjektion</span></section></li> </ul> <p data-tool="mdnice编辑器" style='margin-bottom: 0px;padding-top: 8px;padding-bottom: 8px;outline: 0px;font-family: system-ui, -apple-system, BlinkMacSystemFont, "Helvetica Neue", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei UI", "Microsoft YaHei", Arial, sans-serif;letter-spacing: 0.544px;white-space: normal;background-color: rgb(255, 255, 255);line-height: 26px;'><span style="outline: 0px;font-size: 16px;">where</span><code. style="out Zeile: 0px; "> <code style="outline: 0px;"><span style="outline: 0px;font-size: 16px;">基于字段的依赖注入</span>Feldbasierte Abhängigkeitsinjektion ist weit verbreitet, aber Ideen oder andere statische Code-Analysetools geben sofortige Meldungen aus und werden nicht empfohlen.

Sie können diese Injektionsmethode sogar in einigen offiziellen Spring-Anleitungen sehen:

2.1 Konstruktorbasierte Abhängigkeitsinjektion

Bei der konstruktorbasierten Abhängigkeitsinjektion wird die Klassenkonstruktion mit @ kommentiert Automatisch verdrahtet und enthält eine Reihe von Parametern, die sich auf das einzuspritzende Objekt beziehen.

@Component
public class ConstructorBasedInjection {

    private final InjectedBean injectedBean;

    @Autowired
    public ConstructorBasedInjection(InjectedBean injectedBean) {
        this.injectedBean = injectedBean;
    }
}

public class SimpleMovieLister {

    // the SimpleMovieLister has a dependency on a MovieFinder
    private MovieFinder movieFinder;

    // a constructor so that the Spring container can inject a MovieFinder
    public SimpleMovieLister(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }

    // business logic that actually uses the injected MovieFinder is omitted...
}

基于构造函数注入的主要优点是可以将需要注入的字段声明为final， 使得它们会在类实例化期间被初始化，这对于所需的依赖项很方便。

2.2 基于Setter的依赖注入

在基于setter的依赖注入中，setter方法被标注为 @Autowired。一旦使用无参数构造函数或无参数静态工厂方法实例化Bean，为了注入Bean的依赖项，Spring容器将调用这些setter方法。

@Component
public class SetterBasedInjection {

    private InjectedBean injectedBean;

    @Autowired
    public void setInjectedBean(InjectedBean injectedBean) {
        this.injectedBean = injectedBean;
    }
}

和基于构造器的依赖注入一样，在官方文档中，基于Setter的依赖注入中的 @Autowired也可以省去。

public class SimpleMovieLister {

    // the SimpleMovieLister has a dependency on the MovieFinder
    private MovieFinder movieFinder;

    // a setter method so that the Spring container can inject a MovieFinder
    public void setMovieFinder(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }

    // business logic that actually uses the injected MovieFinder is omitted...
}

2.3 基于属性的依赖注入

在基于属性的依赖注入中，字段/属性被标注为 @Autowired。一旦类被实例化，Spring容器将设置这些字段。

@Component
public class FieldBasedInjection {
    @Autowired
    private InjectedBean injectedBean;
}

正如所看到的，这是依赖注入最干净的方法，因为它避免了添加样板代码，并且不需要声明类的构造函数。代码看起来很干净简洁，但是正如代码检查器已经向我们暗示的那样，这种方法有一些缺点。

In der objektorientierten Programmierung werden die fünf Designprinzipien SOLID häufig verwendet (in China im Allgemeinen sechs Designprinzipien), um die Wiederverwendbarkeit von Code zu verbessern. Lesbarkeit, Zuverlässigkeit und Wartbarkeit

S in SOLID stellt das Prinzip der Einzelverantwortung dar, das heißt, eine Klasse sollte nur für eine Verantwortung verantwortlich sein, und alle von dieser Klasse bereitgestellten Dienste sollten nur für die Verantwortung verantwortlich sein, für die sie verantwortlich ist für Serve.

Mit der feldbasierten Abhängigkeitsinjektion werden wir der Klasse im Laufe der Zeit immer mehr Abhängigkeiten hinzufügen und es ist einfach, die Abhängigkeiten in der Klasse zu ignorieren . Wenn Sie jedoch die konstruktorbasierte Abhängigkeitsinjektion verwenden, wird der Konstruktor immer größer, wenn der Klasse immer mehr Abhängigkeiten hinzugefügt werden, und wir können auf den ersten Blick erkennen, dass etwas nicht stimmt.

Ein Konstruktor mit mehr als 10 Parametern ist ein klares Zeichen dafür, dass sich die Klasse in eine große und umfassende Sammlung von Funktionen verwandelt hat und in kleinere, besser wartbare Teile aufgeteilt werden muss.

Obwohl die Vermögenszuführung keine direkte Ursache für einen Verstoß gegen das Prinzip der Einzelverantwortung ist, verbirgt sie Signale und macht es uns leicht, sie zu ignorieren.

3.3 Eng gekoppelt mit dem Abhängigkeitsinjektionscontainer

Der Hauptgrund für die Verwendung der feldbasierten Abhängigkeitsinjektion besteht darin, Boilerplate-Code für Getter und Setter zu vermeiden oder Konstruktoren für Klassen zu erstellen. Letztendlich bedeutet dies, dass die einzige Möglichkeit, diese Felder festzulegen, darin besteht, die Klasse über den Spring-Container zu instanziieren und sie mithilfe von Reflektion einzufügen, andernfalls bleiben die Felder null.

Das Dependency-Injection-Entwurfsmuster entkoppelt die Erstellung von Klassenabhängigkeiten von der Klasse selbst und überträgt diese Verantwortung auf den Klasseninjektionscontainer, sodass der Programmentwurf entkoppelt werden kann und den Prinzipien der Einzelverantwortung und der Abhängigkeitsumkehr folgt (gleichermaßen zuverlässig). Daher geht die Entkopplung der Klasse, die durch die automatische Verdrahtung von Feldern erreicht wird, schließlich verloren, indem sie erneut an den Klasseninjektionscontainer (in diesem Fall Spring) gekoppelt wird, wodurch die Klasse außerhalb des Spring-Containers unbrauchbar wird.

Das bedeutet, dass Sie, wenn Sie Ihre Klasse außerhalb des Anwendungscontainers verwenden möchten, beispielsweise für Unit-Tests, gezwungen sind, den Spring-Container zum Instanziieren Ihrer Klasse zu verwenden, da es keine andere Möglichkeit (außer Reflektion) zum Einrichten gibt Autowiring-Felder.

3.4 Versteckte Abhängigkeiten

Bei Verwendung der Abhängigkeitsinjektion sollte die betroffene Klasse diese Abhängigkeiten eindeutig über eine öffentliche Schnittstelle offenlegen, indem sie die erforderlichen Abhängigkeiten im Konstruktor offenlegt oder mithilfe von Methoden (Settern) optionale Abhängigkeiten offenlegt. Bei Verwendung der feldbasierten Abhängigkeitsinjektion sind diese Abhängigkeiten im Wesentlichen vor der Außenwelt verborgen.

4. Zusammenfassung

Wir haben gesehen, dass die feldbasierte Injektion möglichst vermieden werden sollte, da sie viele Nachteile mit sich bringt, egal wie elegant sie aussieht. Der empfohlene Ansatz ist die Verwendung einer konstruktorbasierten und setterbasierten Abhängigkeitsinjektion.

Für erforderliche Abhängigkeiten wird empfohlen, eine konstruktorbasierte Injektion zu verwenden, sie unveränderlich zu machen und zu verhindern, dass sie null sind. Für optionale Abhängigkeiten wird die Verwendung einer Setter-basierten Injektion empfohlen.