[JAVA] [Frühling] Bohnenlebenszyklus - von der Generation bis zur Zerstörung -

Überblick

Dieser Artikel fasst den Bohnenlebenszyklus zusammen. Es ist eine ziemlich interne Geschichte. Wir gehen davon aus, dass Sie die folgenden Schlüsselwörter kennen.

• Bean
• DI(Dependency Injection)

Übrigens habe ich die Spring Professional v5.0-Prüfung abgelegt, die neulich von pivotal gesponsert wurde. Dies ist also eine Zusammenfassung dessen, was ich damals gelernt habe.

Bohnen-Lebenszyklus

Der Lebenszyklus einer Bohne ist grob in drei Teile unterteilt.

1. Initialisierungsphase
2. Nutzungsphase
3. Phase beenden

Initialisierungsphase

Hauptsächlich in dieser Phase

• Bean-Definition lesen / umschreiben
• Bohnenerzeugung & DI
• Initialisierungsprozess

halten. Diese Phase ist die komplexeste. Der allgemeine Fluss ist so

Lass uns genauer hinschauen.

Bohnendefinition lesen

Zunächst werden die zum Generieren der Bean erforderlichen Informationen gelesen.

--Java Config mit @ Configuration

• Klassen mit "@ Component", "@ Controller", "@ RestController", "@ Service", "@ Repository"
• XML-Datei mit Bean-Definition

Basierend auf den hier gelesenen Informationen wird eine Bean-Definitionsinformationsliste erstellt. (Die Entität ist BeanDefinition ) Karte des Objekts?) Die Bean-Implementierungsklasse, der Bereich, die abhängigen Beans, Felder usw. werden in die Bean-Definitionsinformationsliste geschrieben.

Umschreiben der Bean-Definition

Hier werden die Bean-Definitionsinformationen neu geschrieben. Es ist ein Bild, das die im vorherigen Schritt erstellte Bean-Definitionsinformationsliste geändert hat. Hier wird beispielsweise das Einbetten eines Eigenschaftswerts in einen mit "@ Value" deklarierten Platzhalter ausgeführt.

AImpl.java

@Component("a")
public class AImpl implements A {

    @Value("${url}")
    private String url;
}

application.properties

url=http://www.sample.com

Tatsächlich wird BeanDefinition basierend auf dem durch @ Value injizierten Eigenschaftswert geändert. BeanFactoryPostProcessor realisiert das Umschreiben von Bean-Definitionsinformationen. factory / config / BeanFactoryPostProcessor.java). Die Verarbeitung wird von der Klasse ausgeführt, die die BeanFactoryPostProcessor-Schnittstelle implementiert.

public interface BeanFactoryPostProcessor {
   void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory);
}

PropertySourcesPlaceholderConfigurer implementiert BeanFactoryPostProcessor für den Prozess des Einbettens von Eigenschaftswerten mit "@ Value" /springframework/context/support/PropertySourcesPlaceholderConfigurer.java) Die Klasse ist verantwortlich. (Siehe den Link für eine detaillierte Verarbeitung) Bei Verwendung von "@ Value" muss übrigens eine Bean definiert werden, die PropertySourcesPlaceholderConfigurer zurückgibt. (Es scheint nicht notwendig zu sein, es explizit zu definieren, wenn es sich um Spring Boot und Spring 4.3 oder höher handelt.) Diese Bean muss in einer statischen Methode definiert werden, da Spring sie ausführt, bevor die Bean erstellt wird.

@Bean
public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
    return new PropertySourcesPlaceholderConfigurer();
}

Damit ist die Generierung von Bean-Definitionsinformationen abgeschlossen. Eigentlich wurde die Bohne noch nicht generiert. Ab der nächsten Phase werden Bohnen erzeugt.

Bohnenerzeugung & DI

Zu diesem Zeitpunkt wird schließlich eine Bean erstellt und DI (Dependency Injection) ausgeführt. DI wird in der folgenden Reihenfolge ausgeführt.

1. Konstruktoreinspritzung
2. Feldinjektion
3. Setter-Injektion

Initialisierungsprozess nach der Bohnengenerierung

Die Initialisierungsverarbeitung wird nach der Bean-Generierung durchgeführt. Als ein Merkmal der Verarbeitung, die hier ausgeführt werden kann, kann die Initialisierungsverarbeitung unter Verwendung der generierten Bean durchgeführt werden. In dieser Phase wird beispielsweise die Verarbeitung der Methode mit "@ PostConstruct" durchgeführt. In der Methode mit @ PostConstruct können Sie den Initialisierungsprozess mit dem injizierten Feld schreiben.

@Component
public class HogeServiceImpl implements HogeService {

    private final Fuga fuga;

    @Autowired
    public HogeServiceImpl(Fuga fuga) {
        this.fuga = fuga;
    }

    //Wird aufgerufen, nachdem DI beendet ist
    //Der Rückgabewert muss ungültig sein, kein Argument
    @PostConstruct
    public void populateCache() {
        ...
    }
}

Vor- und Nachbearbeitung können vor und nach der Initialisierungsverarbeitung dieses Schritts eingefügt werden. Dieser Prozess ist BeanPostProcessor ) Die Klasse, die die Schnittstelle implementiert, macht es.

public interface BeanPostProcessor {
    //Vorverarbeitung
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    //Nachbearbeitung
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

Nutzungsphase

Dies ist die Phase, in der die Bohne tatsächlich verwendet wird.

ApplicationContext context = SpringApplication.run(AppConfig.class);
HogeService service = context.getBean("hogeService", HogeService.class); //Holen Sie sich Bean
service.do(); //Verwendung von Bohnen

Endphase

Dies ist die Phase, in der der DI-Container zerstört wird.

Verarbeitung vor dem Verwerfen

Die Verarbeitung erfolgt vor der Zerstörung des DI-Containers. Methoden mit "@ PreDestroy" werden in dieser Phase verarbeitet.

@Component
public class HogeServiceImpl implements HogeService {

    //Wird aufgerufen, bevor der DI-Container zerstört wird
    //Der Rückgabewert muss ungültig sein, kein Argument
    @PreDestroy
    public void clearCache() {
        ...
    }
}

DI-Behälter entsorgen

Wenn die Methode close von ConfigurableApplicationContext aufgerufen wird Der DI-Container wird zerstört.

context.close();

Wenn es von "SpringApplication.run ()" generiert wird, wird es mit dem Herunterfahren der JVM verbunden und der DI-Container wird zerstört.

ConfigurableApplicationContext context = SpringApplication.run(AppConfig.class);
//ShutdownHook ist in der JVM registriert

Referenzmaterial

• Eine gründliche Einführung in die Entwicklung von Spring Java-Anwendungen mit dem Spring Framework|NTT Data Co., Ltd.|Buch|Versandhandel| Amazon
• https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html