Lente @PostConstruct en @PreDestroy

Wanneer we Spring Beans configureren met behulp van dependency injection, willen we soms zeker stellen dat alles correct wordt geïnitialiseerd voordat onze bean begint met het bedienen van de clientverzoeken. Op dezelfde manier, wanneer de context wordt vernietigd, moeten we mogelijk enkele bronnen sluiten die door de Spring Bean worden gebruikt.

Spring @PostConstruct

Wanneer we een methode in een Spring Bean annoteren met de @PostConstruct-annotatie, wordt deze uitgevoerd nadat de Spring Bean is geïnitialiseerd. We kunnen slechts één methode hebben die is geannoteerd met de @PostConstruct-annotatie. Deze annotatie maakt deel uit van de Common Annotations API en het behoort tot de JDK-module javax.annotation-api. Dus als je deze annotatie gebruikt in Java 9 of hoger, moet je deze jar expliciet aan je project toevoegen. Als je Maven gebruikt, moet de onderstaande afhankelijkheid aan het project worden toegevoegd.

<dependency>
	<groupId>javax.annotation</groupId>
	<artifactId>javax.annotation-api</artifactId>
	<version>1.3.2</version>
</dependency>

Als je Java 8 of een eerdere versie gebruikt, hoef je de bovenstaande afhankelijkheid niet toe te voegen.

Spring @PreDestroy

Wanneer we een Spring Bean-methode annoteren met de PreDestroy-annotatie, wordt deze aangeroepen wanneer de bean-instantie uit de context wordt verwijderd. Dit is een zeer belangrijk punt om te begrijpen – als je spring bean scope “prototype” is, wordt deze niet volledig beheerd door de Spring-container en wordt de PreDestroy-methode niet aangeroepen. Als er een methode is met de naam shutdown of close, zal de Spring-container proberen om ze automatisch te configureren als callback-methoden wanneer de bean wordt vernietigd.

Spring @PostConstruct en @PreDestroy Voorbeeld

Hier is een eenvoudige Spring-bean met @PostConstruct en @PreDestroy methoden.

package com.journaldev.spring;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class MyBean {

	public MyBean() {
		System.out.println("MyBean instance created");
	}

	@PostConstruct
	private void init() {
		System.out.println("Verifying Resources");
	}

	@PreDestroy
	private void shutdown() {
		System.out.println("Shutdown All Resources");
	}

	public void close() {
		System.out.println("Closing All Resources");
	}
}

Merk op dat ik ook een close-methode heb gedefinieerd om te controleren of deze wordt aangeroepen wanneer onze bean wordt vernietigd of niet. Hier is mijn eenvoudige Spring-configuratie klasse.

package com.journaldev.spring;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

@Configuration
public class MyConfiguration {
	
    @Bean
    @Scope(value="singleton")
    public MyBean myBean() {
	return new MyBean();
    }
	
}

I don’t need to explicitly specify my bean as a singleton but I will later change its value to “prototype” and see what happens with @PostConstruct and @PreDestroy methods. Here is my main class where I am creating spring context and getting few instances of MyBean.

package com.journaldev.spring;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MySpringApp {

	public static void main(String[] args) {
		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
		ctx.register(MyConfiguration.class);
		ctx.refresh();

		MyBean mb1 = ctx.getBean(MyBean.class);
		System.out.println(mb1.hashCode());

		MyBean mb2 = ctx.getBean(MyBean.class);
		System.out.println(mb2.hashCode());

		ctx.close();
	}

}

Wanneer we bovenstaande klasse uitvoeren, krijgen we de volgende uitvoer.

MyBean instance created
Verifying Resources
1640296160
1640296160
Shutdown All Resources
Closing All Resources

Dus wordt de methode @PostConstruct aangeroepen nadat het bean-object is geïnstantieerd. Wanneer de context wordt afgesloten, worden zowel de shutdown- als de close-methode aangeroepen.

Spring @PostConstruct en @PreDestroy met Prototype Scope

Wijzig gewoon de scope-waarde naar prototype in MyConfiguration en voer de hoofdklasse uit. Je krijgt een output zoals hieronder.

MyBean instance created
Verifying Resources
1640296160
MyBean instance created
Verifying Resources
1863374262

Het is dus duidelijk dat de Spring-container de bean initialiseert bij elke aanvraag, de @PostConstruct-methode ervan aanroept en deze vervolgens overdraagt aan de client. Spring beheert de bean daarna niet meer en in dit geval moet de client alle resource-opruiming uitvoeren door de PreDestroy-methode rechtstreeks aan te roepen.

Samenvatting

@PostConstruct en @PreDestroy zijn belangrijke annotaties die worden gebruikt bij het beheer van de levenscyclus van spring beans. We kunnen ze gebruiken om te controleren of een bean correct is geïnitialiseerd en vervolgens alle resources te sluiten wanneer de bean uit de spring-context wordt verwijderd.

Je kunt de volledige projectcode bekijken op onze GitHub Repository.