37

I am working on a simple Java EE application.

I have class like this:

import javax.annotation.PostConstruct;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

@Stateless
public class BlogEntryDao {

    EntityManager em;

    @PostConstruct
    public void initialize(){
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("Persistence");
        em = emf.createEntityManager();
    }

    public void addNewEntry(){
        Blogentry blogentry = new Blogentry();

        blogentry.setTitle("Test");
        blogentry.setContent("asdfasfas");

        em.persist(blogentry);

    }
}

So my managed bean calls this method. Until here no problems. But since the initialize method is not called, I am getting an NPE in em.persist.

Why is the initialize method not being called? I am running this on Glassfish server.

Regards.

Koray Tugay
  • 22,894
  • 45
  • 188
  • 319
  • 3
    For starters, you shouldn't be opening your `EntityManager` in a global scope; the `EntityManager` roughly corresponds to a session. If you really need to handle your own session management (injecting @PersistenceContext is better), you should be creating and closing an `EntityManager` in each call to `addNewEntry`. – chrylis -cautiouslyoptimistic- Aug 10 '13 at 12:07
  • 1
    Have you confirmed that your container is treating the object as something requiring dependency injection? Not every object gets hooked into, and if you're just calling `new BlogEntryDao()` somewhere, the container may not know to initialize it as a bean. – chrylis -cautiouslyoptimistic- Aug 10 '13 at 12:08
  • @chrylis Yeah thanks, I am calling new BlogEntryDao actually. – Koray Tugay Aug 10 '13 at 12:09
  • @chrylis Thanks, changing it to EJB BlogEntryDao fixed it. Can you please proivde an answer so I can accept it? – Koray Tugay Aug 10 '13 at 12:13
  • I think you can define init-method="initialize" in the bean configuration file. – Weidian Huang Dec 20 '16 at 05:49

9 Answers9

29

The Java EE bean annotations such as @PostConstruct only apply to container-managed beans. If you are simply calling new BlogEntryDao yourself, the container isn't going to intercept the creation and call the @PostConstruct method.

(Furthermore, you'd be better off using @PersistenceContext or @PersistenceUnit instead of manually fetching the EntityManagerFactory in your initialize() method, and you should be creating an EntityManager for each call to addNewEntry(), since they're short-lived. Making these changes would eliminate the need for initialize() at all.)

chrylis -cautiouslyoptimistic-
  • 75,269
  • 21
  • 115
  • 152
19

Since this question comes up first on Google for "postconstruct not called", another reason a @PostConstruct method might not be called besides using the new keyword instead of putting @PostConstruct in a Spring bean is if you have a circular dependency.

If this bean were to depend on another bean that depended on this bean, your other bean might call addNewEntry() before BlogEntryDao was initialized, even though BlogEntryDao is a dependency for that other bean.

This is because Spring didn't know which bean you wanted to load first due to the circular reference. In this case, one can remove the circular reference or use @AutoWired/@Value constructor parameters instead of member values or setters, or if using xml configuration, maybe you can swap the order in which the beans are defined.

Mark W
  • 5,824
  • 15
  • 59
  • 97
Alexander Taylor
  • 16,574
  • 14
  • 62
  • 83
19

I had the same problem in my application. You didn't post your bean context configuration xml file (so I'm not sure if it's the same issue) but in my case adding this line:

<context:annotation-config/>

Solved my problem. You need either <context:annotation-config/> or <context:component-scan/> to enable @PostConstruct annotation.

Tomasz Kubiak
  • 370
  • 4
  • 8
  • 2
    Note: this is correct for Spring applications but the question was about general JavaEE applications. – stefan.m Jan 30 '17 at 14:41
6

In my case @PostConstruct was not called because my initialize() method was static and was also throwing an exception. In either case the method is ignored. I hope it helps someone else who made the same mistake. This can be found in the console:

WARNING: JSF1044: Method '<XXX>' marked with the 'javax.annotation.PostConstruct' annotation cannot be static.  This method will be ignored.
WARNING: JSF1047: Method '<XXX>' marked with the 'javax.annotation.PostConstruct' annotation cannot declare any checked exceptions.  This method will be ignored.
divaylo
  • 71
  • 2
  • 5
4

When using Spring make sure you are using the right PostConstruct annotation from the right package.

javax.annotation.PostConstruct

should be the one. Not for example:

jakarta.annotation.PostConstruct

It took me a little while to figure out why only one of my PostConstruct didn't work.

Tinus Tate
  • 2,237
  • 2
  • 12
  • 33
2

In my case @PostConstruct method was not called because I was referencing to a public instance variable of the spring service bean directly in other service beans (ie myService.myProperty). When i made a public getter method for the property (ie getMyProperty()) and used that to get the property the @PostConstruct method was called again. Also I made myProperty private to prevent any accidental direct referencing in the future.

Also note that if you don't explicitly register the class with @Bean in a @Configuration annotated class and rely soley on @Autowired instead, the @PostConstruct method may not be executed immediately on startup. Only when one of the methods of the autowired class are referenced and called by another class will that class be loaded and only at that time will the @PostConstruct method be called. In other words, by only using @Autowired you are essentially lazy loading a class. If you want to load it at startup, register it with @Bean

Heres a good SO thread about the difference between @Bean and @Autowired Difference between @Bean and @Autowired

EDIT: One last remark. When you have a webapplication and decided to annotate your class with @RequestScope then the @Postconstruct annotated method will be called each time when a new request comes in. This is because @RequestScope instructs spring to create a new instance of the class every time a new request comes in. If you want all requests to use the same instance, then you could use @Bean as mentioned above, but you could also use the annotation @Singleton above your class. This will cause the class to be loaded eagerly upon startup.

Maurice
  • 6,698
  • 9
  • 47
  • 104
1

Make sure the class having @Postconstruct method lies within the same package. I moved class file to main package and it worked.

amitsatputecd7
  • 351
  • 4
  • 10
0

In my case I had two instances of javax.annotation.PostConstruct inside classpath. One was bundled with the war package and another was provided by tomcat. When Spring is scanning for the @PostConstruct annotation it compares these two different instances. Therefore the @PostConstruct annotated method was not picked while scanning.

Providing only one instance of javax.annotation-api library solved the issue.

Tanimak
  • 134
  • 1
  • 9
0

Since most of the ways are already mentioned. However one can also create a bean in the config file for the class

org.springframework.context.annotation.CommonAnnotationBeanPostProcessor

;

This will enable PostConstruct and PreDestroy annotations.

<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"></bean>

Also for Predestroy one needs to call context.registerShutDownHook()

curiousP
  • 1