BeanNameAware- und BeanFactoryAware-Schnittstellen im Frühling

1. Überblick

In diesem kurzen Tutorial werden wir uns auf die Schnittstellen BeanNameAware und BeanFactoryAware im Spring Framework ** konzentrieren.

Wir beschreiben jede Schnittstelle separat mit den Vor- und Nachteilen ihrer Verwendung.

**2. Aware Schnittstelle**

Sowohl BeanNameAware als auch BeanFactoryAware gehören zur org.springframework.beans.factory.Aware -Root-Marker-Schnittstelle.

Dies verwendet die Setterinjektion, um ein Objekt während des Anwendungskontextstarts abzurufen.

Die Aware -Schnittstelle ist eine Mischung aus Callback-, Listener- und Observer-Entwurfsmustern ** . Es zeigt an, dass die Bean vom Spring-Container über die Callback-Methoden benachrichtigt werden kann.

3. BeanNameAware

BeanNameAware macht das Objekt auf den im Container definierten Bean-Namen aufmerksam **

Schauen wir uns ein Beispiel an:

public class MyBeanName implements BeanNameAware {

    @Override
    public void setBeanName(String beanName) {
        System.out.println(beanName);
    }
}

Die Eigenschaft beanName repräsentiert die im Spring-Container registrierte Bean-ID. In unserer Implementierung wird lediglich der Bean-Name angezeigt.

Als nächstes registrieren wir eine Bean dieses Typs in einer Spring-Konfigurationsklasse:

@Configuration
public class Config {

    @Bean(name = "myCustomBeanName")
    public MyBeanName getMyBeanName() {
        return new MyBeanName();
    }
}

Hier haben wir unserer MyBeanName -Klasse mit der @ Bean (name = „myCustomBeanName“) -Zeile explizit einen Namen zugewiesen.

Jetzt können wir den Anwendungskontext starten und die Bean daraus abrufen:

AnnotationConfigApplicationContext context
  = new AnnotationConfigApplicationContext(Config.class);

MyBeanName myBeanName = context.getBean(MyBeanName.class);

Wie erwartet, gibt die Methode setBeanName "myCustomBeanName" aus.

Wenn wir den name = "…" - Code aus der Annotation @ Bean entfernen, weist der Container in diesem Fall den getMyBeanName () Methodennamen der Bean zu. Die Ausgabe ist also "getMyBeanName" .

4. BeanFactoryAware

BeanFactoryAware wird zum Einfügen des BeanFactory -Objekts ** verwendet. Auf diese Weise erhalten wir Zugriff auf die BeanFactory , die das Objekt erstellt hat.

Hier ist ein Beispiel für eine MyBeanFactory -Klasse:

public class MyBeanFactory implements BeanFactoryAware {

    private BeanFactory beanFactory;

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }

    public void getMyBeanName() {
        MyBeanName myBeanName = beanFactory.getBean(MyBeanName.class);
        System.out.println(beanFactory.isSingleton("myCustomBeanName"));
    }
}

Mit Hilfe der Methode setBeanFactory () weisen wir die BeanFactory -Referenz aus dem IoC-Container der beanFactory-Eigenschaft zu.

Danach können wir es direkt wie in der Funktion getMyBeanName () verwenden.

Initialisieren wir die MyBeanFactory und rufen die getMyBeanName () -Methode auf:

MyBeanFactory myBeanFactory = context.getBean(MyBeanFactory.class);
myBeanFactory.getMyBeanName();

Da wir die MyBeanName -Klasse im vorherigen Beispiel bereits instanziiert haben, ruft Spring hier die vorhandene Instanz auf.

Die Zeile __beanFactory.isSingleton ("myCustomBeanName") überprüft dies.

5. Wann verwenden?

Der typische Anwendungsfall für BeanNameAware könnte der Bean-Name für Protokollierungs- oder Verdrahtungszwecke sein. Für die BeanFactoryAware könnte es die Möglichkeit sein, eine Spring-Bean aus älterem Code zu verwenden.

In den meisten Fällen sollten wir die Verwendung der Aware -Schnittstellen vermeiden, sofern wir sie nicht benötigen. Durch die Implementierung dieser Schnittstellen wird der Code an das Spring-Framework gekoppelt.

6. Fazit

In diesem Beitrag haben wir die Schnittstellen BeanNameAware und BeanFactoryAware und deren praktische Anwendung kennen gelernt.

Wie üblich ist der vollständige Code für diesen Artikel verfügbar over auf GitHub .

TOC