Pourquoi utiliser @PostConstruct?

La principal problème est que:

dans un constructeur, l'injection de dépendances n'a pas encore eu lieu*

_{*excluant évidemment Constructeur Injection}

---

Exemple réel:

public class Foo {

    @Inject
    Logger LOG;

    @PostConstruct
    public void fooInit(){
        LOG.info("This will be printed; LOG has already been injected");
    }

    public Foo() {
        LOG.info("This will NOT be printed, LOG is still null");
        //NullPointerException will be thrown here
    }
}

---

IMPORTANT:
@PostConstruct et @PreDestroy ont été complètement retiré en Java 11.

De continuer de les utiliser, vous aurez besoin d'ajouter le javax.annotation-api POT à vos dépendances.

Maven

<!-- https://mvnrepository.com/artifact/javax.annotation/javax.annotation-api -->
<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>

Gradle

//https://mvnrepository.com/artifact/javax.annotation/javax.annotation-api
compile group: 'javax.annotation', name: 'javax.annotation-api', version: '1.3.2'

Envisagez le scénario suivant:

public class Car {
  @Inject
  private Engine engine;  

  public Car() {
    engine.initialize();  
  }
  ...
}

Depuis la Voiture doit être instancié avant le domaine de l'injection, le point d'injection du moteur est toujours null lors de l'exécution du constructeur, résultant en une NullPointerException.

Ce problème peut être résolu soit par JSR 330 Injection de Dépendance pour Java constructeur de l'injection ou de la JSR 250 Commun Annotations de Java @PostConstruct méthode d'annotation.

@PostConstruct

JSR 250 définit un ensemble commun d'annotations qui a été inclus dans Java SE 6.

La PostConstruct annotation est utilisée sur une méthode qui doit être
exécuté après l'injection de dépendance est fait pour effectuer toutes les
l'initialisation. Cette méthode DOIT être appelée avant la classe est mis
en service. Cette annotation DOIT être pris en charge sur toutes les classes qui
le soutien de l'injection de dépendances.

JSR 250 Chap. 2.5 javax.annotation.PostConstruct

L' @PostConstruct annotation permet la définition de méthodes pour être exécuté après que l'instance a été instancié et toutes injecte ont été effectuées.

public class Car {
  @Inject
  private Engine engine;  

  @PostConstruct
  public void postConstruct() {
    engine.initialize();  
  }
  ...
} 

Au lieu d'effectuer l'initialisation dans le constructeur, le code est déplacé à une méthode annotée avec @PostConstruct.

Le traitement de post-construire des méthodes est une simple question de trouver toutes les méthodes annotées avec @PostConstruct et les invoquer à son tour.

private  void processPostConstruct(Class type, T targetInstance) {
  Method[] declaredMethods = type.getDeclaredMethods();

  Arrays.stream(declaredMethods)
      .filter(method -> method.getAnnotation(PostConstruct.class) != null) 
      .forEach(postConstructMethod -> {
         try {
           postConstructMethod.setAccessible(true);
           postConstructMethod.invoke(targetInstance, new Object[]{});
        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {      
          throw new RuntimeException(ex);
        }
      });
}

Le traitement de post-construire des méthodes doit être effectuée après l'instanciation et l'injection ont été achevés.