What is the difference between @Postconstruct and the constructor?

Question

What’s the difference of using the annotation @PostConstruct instead of using constructor method and its advantages? I ask based on these two versions of the same class that only differ by this annotation.

Before

@Repository
public class OldValidacaoDAO {

    MongoCollection mongoCollection;

    public OldValidacaoDAO() {
        this.mongoCollection = DBSingleton.getJongo().getCollection("validacao_validacoes");
    }
}

Afterward

@Repository
public class ValidacaoDAO {

    MongoCollection mongoCollection;

    @PostConstruct
    public void init(){
        this.mongoCollection = DBSingleton.getJongo().getCollection("validacao_validacoes");
    }

}

Answer 1

When using frameworks that manage the lifecycle of your classes, as is the case with Spring, it is always important to understand that an instance managed by the framework is not just any instance.

An instance managed by Spring is called Spring Bean and is not a common object. He now has superpowers.

Common Instance vs. Spring Bean

Consider the following class:

@Service
public class MeuServico {

    @Autowired MeuDao meuDao;

    public void acao() {
       meuDao.atualizarBanco();
    }

}

What happens if you create the class manually?

MeuServico meuServico = new MeuServico();
meuServico.acao();

The result will be a NullPonterException on the line meuDao.atualizarBanco(), for the attribute meuDao will be void.

A normal object is not managed by Spring.

So whenever you wear one Spring Bean you should let Spring deliver you the instance, whether through an annotation, injection through XML, etc.

Constructor vs. Post-constructor

When Spring starts context (Spring Context), which contains all the Beans, it creates instances of the Beans annotated or declared in configuration, processes annotations, injects dependencies and some more.

After properly initializing everything, it calls the method that is annotated with @PostConstruct.

Note that at the moment the instance is created, there is nothing injected or initialized.

Therefore, the code below would also result in a NullPointerException:

@Service
public class MeuServico {

    @Autowired MeuDao meuDao;

    public MeuServico() {
       meuDao.iniciarAlgumaCoisaNoBanco();
    }

}

Look, Spring won’t be able to inject meuDao before instantiating the class. Therefore in any framework it is not possible to inject the dependency or do anything else in the class before calling some constructor.

The solution is to use the post-constructor, which then allows you to perform some action right after Spring startup, but before the system performs some user action.