Was in aller Welt sind Frühlingsbohnen?

Ich muss noch eine allgemeine Definition von Frühlingsbohnen finden, die ich verstehen kann. Ich sehe sie oft in Grails Dokumentation und Büchern erwähnt, aber ich denke, dass es von Vorteil wäre, zu verstehen, was sie sind. Was sind Frühlingsbohnen? Wie können sie verwendet werden? Haben sie etwas mit Abhängigkeitsinjektion zu tun?

Die Objekte, die das Rückgrat Ihrer Anwendung bilden und vom Spring IoC * -Container verwaltet werden, werden als Beans bezeichnet. Eine Bean ist ein Objekt, das von einem Spring IoC-Container instanziiert, zusammengestellt und anderweitig verwaltet wird. Diese Beans werden mit den Konfigurationsmetadaten erstellt, die Sie dem Container beispielsweise in Form von XML- <bean/>Definitionen zur Verfügung stellen.

Weitere Informationen zu Beans und Scope von SpringSource :

Wenn Sie eine Bean-Definition erstellen, erstellen Sie tatsächlich ein Rezept zum Erstellen tatsächlicher Instanzen der durch diese Bean-Definition definierten Klasse. Die Idee, dass eine Bean-Definition ein Rezept ist, ist wichtig, da dies bedeutet, dass Sie wie bei einer Klasse möglicherweise viele Objektinstanzen aus einem einzigen Rezept erstellen können.

Sie können nicht nur die verschiedenen Abhängigkeiten und Konfigurationswerte steuern, die in ein Objekt eingefügt werden sollen, das aus einer bestimmten Bean-Definition erstellt wird, sondern auch den Umfang der Objekte, die aus einer bestimmten Bean-Definition erstellt werden. Dieser Ansatz ist sehr leistungsfähig und bietet Ihnen die Flexibilität, den Bereich der Objekte zu wählen, die Sie durch Konfiguration erstellen, anstatt den Bereich eines Objekts auf Java-Klassenebene "einbacken" zu müssen. Beans können so definiert werden, dass sie in einem von mehreren Bereichen eingesetzt werden

* IoC: Inversion der Kontrolle

Spring Beans sind nur Instanzobjekte, die vom Spring-Container verwaltet werden. Sie werden vom Framework erstellt und verkabelt und in einen "Beutel mit Objekten" (den Container) gestellt, von dem Sie sie später abrufen können.

Der "Verkabelungsteil" dort ist, worum es bei der Abhängigkeitsinjektion geht. Das bedeutet, dass Sie einfach "Ich werde dieses Ding brauchen" sagen können und das Framework einige Regeln befolgt, um die richtige Instanz zu erhalten.

Für jemanden, der nicht an Spring gewöhnt ist, hat der Artikel von Wikipedia Spring eine schöne Beschreibung :

Im Mittelpunkt des Spring Frameworks steht die Inversion des Steuercontainers, mit der Java-Objekte mithilfe von Reflection konsistent konfiguriert und verwaltet werden können. Der Container ist für die Verwaltung der Objektlebenszyklen bestimmter Objekte verantwortlich: Erstellen dieser Objekte, Aufrufen ihrer Initialisierungsmethoden und Konfigurieren dieser Objekte durch Verdrahtung.

Vom Container erstellte Objekte werden auch als verwaltete Objekte oder Beans bezeichnet . Der Container kann durch Laden von XML-Dateien oder Erkennen bestimmter Java-Anmerkungen zu Konfigurationsklassen konfiguriert werden. Diese Datenquellen enthalten die Bean-Definitionen, die die zum Erstellen der Beans erforderlichen Informationen enthalten.

Objekte können entweder durch Abhängigkeitssuche oder durch Abhängigkeitsinjektion erhalten werden . Die Abhängigkeitssuche ist ein Muster, bei dem ein Aufrufer das Containerobjekt nach einem Objekt mit einem bestimmten Namen oder einem bestimmten Typ fragt. Die Abhängigkeitsinjektion ist ein Muster, bei dem der Container Objekte über Konstruktoren, Eigenschaften oder Factory-Methoden namentlich an andere Objekte übergibt.

Lassen Sie uns zuerst den Frühling verstehen:

Der Frühling ist ein leichtes und flexibles Gerüst.

Analogie:

Bean: ist ein Objekt, das in Spring Container erstellt, verwaltet und zerstört wird. Wir können ein Objekt über die Metadaten (entweder XML oder Annotation) in den Spring Container einfügen, was als Inversion der Steuerung bezeichnet wird.

Analogie: Nehmen wir an, der Landwirt hat ein Ackerland, das mit Samen (oder Bohnen) kultiviert wird. Hier ist Farmer Spring Framework, Ackerland Spring Container, Bohnen Spring Beans, Kultivierung Spring Processors.

Wie der Bohnenlebenszyklus haben auch die Frühlingsbohnen einen eigenen Lebenszyklus.

img Quelle

Es folgt die Abfolge eines Bohnenlebenszyklus im Frühjahr:

• Instanziieren: Zuerst findet der Spring-Container die Definition der Bean aus der XML-Datei und instanziiert die Bean.

• Eigenschaften füllen: Mit der Abhängigkeitsinjektion füllt spring alle Eigenschaften, die in der Bean-Definition angegeben sind.

• Bean-Name festlegen: Wenn die Bean implementiert wird BeanNameAware Schnittstelle , übergibt spring die ID der Bean an die setBeanName()Methode.

• Bean Factory BeanFactoryAwareeinstellen : Wenn Bean die Schnittstelle implementiert , übergibt Spring die Beanfactory ansetBeanFactory() Methode.

• Vorinitialisierung: Wird auch als Nachbearbeitung von Bean bezeichnet. Wenn der Bean Bean BeanPostProcessors zugeordnet sind, ruft Spring aufpostProcesserBeforeInitialization() Methode auf.

• Beans initialisieren: Wenn die Beans implementiert wird IntializingBean, ist esafterPropertySet() Methode aufgerufen. Wenn die Bean über eine Deklaration der Init-Methode verfügt, wird die angegebene Initialisierungsmethode aufgerufen.

• Nachinitialisierung: - Wenn BeanPostProcessorsder Bean etwas zugeordnet ist, wird derenpostProcessAfterInitialization() Methoden aufgerufen.

• Gebrauchsfertig: Jetzt kann die Bean von der Anwendung verwendet werden

• Zerstören: Wenn die Bean implementiert wird DisposableBean, wird die destroy()Methode aufgerufen

Nun, du hast es teilweise verstanden. Sie müssen die Bohnen nach Ihren Bedürfnissen anpassen und Spring Container informieren, um sie bei Bedarf zu verwalten, indem Sie eine von Martin Fowler geprägte Methode namens IoC ( Inversion of Control ) verwenden , die auch als Dependency Injection bezeichnet wird (DI) bezeichnet wird.

Sie verdrahten die Beans so, dass Sie sich nicht um die Instanziierung kümmern oder eine Abhängigkeit von der Bean auswerten müssen. Dies ist im Volksmund als Hollywood-Prinzip bekannt .

Google ist das beste Tool, um mehr darüber zu erfahren, zusätzlich zu den Links, mit denen Sie hier in dieser Frage überflutet würden. :) :)

Frühling haben den IoC-Behälter, der den Beutel der Bohne trägt; Die Pflege und Löschung der Erstellung liegt in der Verantwortung von Spring Container. Wir können die Bohne durch Verkabelung und automatische Verkabelung in den Frühling bringen. Wiring bedeutet, dass wir es manuell in der XML-Datei konfigurieren und "Auto Wiring" bedeutet, dass wir die Anmerkungen in die Java-Datei einfügen. Spring scannt dann automatisch den Root-Kontext, in dem sich die Java-Konfigurationsdatei befindet, erstellt sie und legt sie in die Tasche von Spring.

Hier ist die Detail-URI, in der Sie weitere Informationen zu Bohnen erhalten haben

Frühlingsbohnen sind Klassen. Anstatt eine Klasse zu instanziieren (mit new), erhalten Sie eine Instanz als beanUmwandlung in Ihren Klassentyp aus dem Anwendungskontext, wobei die Bean das ist, was Sie in der Anwendungskontextkonfiguration konfiguriert haben. Auf diese Weise verwaltet die gesamte Anwendung die Singleton-Scope-Instanz in der gesamten Anwendung. Alle Beans werden direkt nach der Instanziierung des Anwendungskontexts in ihrer Konfigurationsreihenfolge initialisiert. Auch wenn Ihre Anwendung keine Beans enthält, werden alle Beans-Instanzen bereits in dem Moment erstellt, in dem Sie den Anwendungskontext erstellt haben.

• Spring Beans sind nur Objektinstanzen, die vom Spring IOC-Container verwaltet werden.

• Spring IOC-Container tragen den Beutel mit Bohnen. Das Erstellen, Verwalten und Löschen von Bohnen liegt in der Verantwortung von Spring Container.

• Wir können die Bohne durch Verkabelung und automatische Verkabelung in den Frühling bringen.

• Verkabelung bedeutet, dass wir es manuell in der XML-Datei konfigurieren.

• Auto Wiring bedeutet, dass wir die Anmerkungen in die Java-Datei einfügen und Spring dann automatisch den Root-Kontext scannt, in dem sich die Java-Konfigurationsdatei befindet, sie erstellt und in die Tasche von Spring legt.

Eine Bean ist ein POJO (Plain Old Java Object), das vom Spring Container verwaltet wird.

Spring-Container erstellen standardmäßig nur eine Instanz der Bean. Diese Bean wird im Speicher zwischengespeichert, sodass alle Anforderungen für die Bean einen gemeinsamen Verweis auf dieselbe Bean zurückgeben.

Die Annotation @Bean gibt ein Objekt zurück, das Spring im Anwendungskontext als Bean registriert. Die Logik innerhalb der Methode ist für die Erstellung der Instanz verantwortlich.

Wann verwenden wir die @ Bean-Annotation?

Wenn die automatische Konfiguration keine Option ist. Zum Beispiel, wenn wir Komponenten aus einer Bibliothek eines Drittanbieters verkabeln möchten, weil der Quellcode nicht verfügbar ist und wir die Klassen nicht mit @Component kommentieren können.

Ein Echtzeitszenario könnte sein, dass jemand eine Verbindung zum Amazon S3-Bucket herstellen möchte. Da die Quelle nicht verfügbar ist, müsste er eine @bean erstellen.

@Bean
public AmazonS3 awsS3Client() {
    BasicAWSCredentials awsCreds = new BasicAWSCredentials(awsKeyId, accessKey);
    return AmazonS3ClientBuilder.standard().withRegion(Regions.fromName(region))
            .withCredentials(new AWSStaticCredentialsProvider(awsCreds)).build();
}

Quelle für den obigen Code -> https://www.devglan.com/spring-mvc/aws-s3-java

Weil ich oben @Component Annotation erwähnt habe.

@Component Gibt an, dass eine mit Anmerkungen versehene Klasse eine "Komponente" ist. Solche Klassen werden als Kandidaten für die automatische Erkennung angesehen, wenn annotationsbasierte Konfiguration und Klassenpfad-Scan verwendet werden.

Die Komponentenanmerkung registriert die Klasse als einzelne Bean.

In Spring werden die Objekte, die das Rückgrat Ihrer Anwendung bilden und vom Spring IoC-Container verwaltet werden, als Beans bezeichnet. Eine Bean ist einfach ein Objekt, das von einem Spring IoC-Container instanziiert, zusammengestellt und anderweitig verwaltet wird.

Für den Frühling sind alle Objekte Bohnen! Der grundlegende Schritt im Spring Framework besteht darin, Ihre Objekte als Beans zu definieren. Beans sind nichts anderes als Objektinstanzen, die vom Spring-Framework unter Berücksichtigung ihrer Klassendefinitionen erstellt werden. Diese Definitionen bilden im Wesentlichen die Konfigurationsmetadaten. Das Framework erstellt dann einen Plan, für den Objekte instanziiert werden müssen, welche Abhängigkeiten festgelegt und eingefügt werden müssen, den Umfang der neu erstellten Instanz usw. basierend auf diesen Konfigurationsmetadaten.

Die Metadaten können wie im ersten Kapitel in einer einfachen XML-Datei bereitgestellt werden. Alternativ können die Metadaten als Anmerkung oder Java-Konfiguration bereitgestellt werden.

Buch: Nur Frühling

Die XML-Konfiguration von Spring besteht aus Beans und Beans sind im Grunde Klassen. Es sind nur POJOs, die wir in unserem ApplicationContext verwenden. Das Definieren von Beans kann als Ersatz für das Schlüsselwort new angesehen werden. Wo immer Sie das Schlüsselwort new in Ihrer Anwendung verwenden, etwa:

MyRepository myRepository =new MyRepository ();

Wenn Sie dieses neue Schlüsselwort verwenden , können Sie diese Konfiguration entfernen und in eine XML-Datei einfügen. Also werden wir so codieren:

<bean name="myRepository " 
      class="com.demo.repository.MyRepository " />

Jetzt können wir einfach Setter Injection / Constructor Injection verwenden. Ich benutze Setter Injection.

public class MyServiceImpl implements MyService {
    private MyRepository myRepository;
    public void setMyRepository(MyRepository myRepository)
        {
    this.myRepository = myRepository ;
        }
public List<Customer> findAll() {
        return myRepository.findAll();
    }
}