Was ist eine Frühlingsbohne?

1. Überblick

Bean ist ein Schlüsselkonzept des Spring Framework. Daher ist es wichtig, diesen Begriff zu verstehen, um den Überblick über das Framework zu behalten und es effektiv zu nutzen.

Leiderthere aren’t clear answers to a simple question – what a Spring bean really is. Einige Erklärungen sind so niedrig, dass ein großes Bild übersehen wird, während andere zu vage sind.

In diesem Tutorial wird versucht, das Thema zu beleuchten, beginnend mit einer Beschreibung in der offiziellen Dokumentation.

Weitere Lektüre:

Warum sollten Sie Spring als Ihr Java Framework wählen?

Ein schneller und praktischer Überblick über das Hauptnutzenversprechen von Spring Framework.

Grundlegendes zu getBean () im Frühjahr

Erfahren Sie mehr über die verschiedenen Varianten der BeanFactory.getBean () -Methode von Spring zum Abrufen einer Bean-Instanz aus dem Spring-Container

2. Bean Definition

Hier ist eine Definition von Bohnen inthe Spring Framework documentation:

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 ein Objekt, das von einem Spring IoC-Container instanziiert, zusammengestellt und anderweitig verwaltet wird.

Diese Definition ist prägnant und bringt es auf den Punkt:but misses an important thing – Spring IoC container. Gehen wir das Kaninchenloch hinunter, um zu sehen, was es ist und welche Vorteile es bringt.

3. Umkehrung der Kontrolle

Einfach ausgedrückt istIhttps: //www.example.com/inversion-control-and-dependency-injection-in-spring [nversion of Control], kurz IoC,a process in which an object defines its dependencies without creating them. Dieses Objekt delegiert die Aufgabe, solche Abhängigkeiten zu einem IoC-Container zu konstruieren.

Beginnen wir mit der Deklaration einiger Domänenklassen, bevor wir in IoC eintauchen.

3.1. Domänenklassen

Angenommen, wir haben eine Klassendeklaration:

public class Company {
    private Address address;

    public Company(Address address) {
        this.address = address;
    }

    // getter, setter and other properties
}

Diese Klasse benötigt einen Mitarbeiter vom TypAddress:

public class Address {
    private String street;
    private int number;

    public Address(String street, int number) {
        this.street = street;
        this.number = number;
    }

    // getters and setters
}

3.2. Traditioneller Ansatz

Normalerweise erstellen wir Objekte mit den Konstruktoren ihrer Klassen:

Address address = new Address("High Street", 1000);
Company company = new Company(address);

An diesem Ansatz ist nichts auszusetzen, aber wäre es nicht schön, die Abhängigkeiten besser zu verwalten?

Stellen Sie sich eine Anwendung mit Dutzenden oder sogar Hunderten von Klassen vor. Manchmal möchten wir eine einzelne Instanz einer Klasse für die gesamte Anwendung freigeben, manchmal benötigen wir ein separates Objekt für jeden Anwendungsfall und so weiter.

Die Verwaltung einer solchen Anzahl von Objekten ist ein wahrer Albtraum. This is where Inversion of Control comes to the rescue.

Anstatt Abhängigkeiten selbst zu erstellen, kann ein Objekt seine Abhängigkeiten aus einem IoC-Container abrufen. All we need to do is to provide the container with appropriate configuration metadata.

3.3. Bean-Konfiguration

Lassen Sie uns zunächst die KlasseCompanymit der Anmerkung@Componentdekorieren:

@Component
public class Company {
    // this body is the same as before
}

Hier ist eine Konfigurationsklasse, die einem IoC-Container Bean-Metadaten bereitstellt:

@Configuration
@ComponentScan(basePackageClasses = Company.class)
public class Config {
    @Bean
    public Address getAddress() {
        return new Address("High Street", 1000);
    }
}

Die Konfigurationsklasse erzeugt eine Bean vom TypAddress. Es enthält auch die Annotation@ComponentScan, die den Container anweist, nach Beans in dem Paket zu suchen, das die KlasseCompany enthält.

Wenn ein Spring IoC-Container Objekte dieser Art erstellt, werden alle Objekte als Spring Beans bezeichnet, da sie vom IoC-Container verwaltet werden.

3.4. IoC in Aktion

Da wir Beans in einer Konfigurationsklasse definiert haben,we’ll need an instance of the AnnotationConfigApplicationContext class to build up a container:

ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);

Ein schneller Test bestätigt die Existenz und die Eigenschaftswerte unserer Bohnen:

Company company = context.getBean("company", Company.class);
assertEquals("High Street", company.getAddress().getStreet());
assertEquals(1000, company.getAddress().getNumber());

Das Ergebnis zeigt, dass der IoC-Container Beans korrekt erstellt und initialisiert hat.

4. Fazit

In diesem Tutorial wurden Spring Beans und ihre Beziehung zu einem IoC-Container kurz beschrieben.

Den vollständigen Quellcode für dieses Tutorial finden Sie unterover on GitHub.

TOC

Was ist eine Frühlingsbohne?