When to use f:viewAction / preRenderView versus PostConstruct?

When should one use the f:viewAction or preRenderView event to initialize data for a page versus using the @PostConstruct annotation? Is the rationale to use one or the other based on the type of scope of the backing bean e.g. If the backing bean is @RequestScoped, then would the choice of using f:viewAction or preRenderView over @PostConstruct to initialize your backing bean prior to rendering the view be irrelevant as the two would result in the same effect?

f:viewAction or preRenderView

<f:metadata>
  <f:viewAction action="#{myBean.initialize}" />
</f:metadata>

<f:metadata>
  <f:event type="preRenderView" listener="#{myBean.initialize}"/>
</f:metadata>

or

@PostConstruct

public class MyBean
{
    @PostConstruct
    public void initialize()
    {

    }
}

> When should one use the f:viewAction or preRenderView event to initialize data for a page verses using the @PostConstruct annotation?

Use the <f:viewAction> when you want to execute a method before the HTML is been rendered. This is particularly useful if you want to perform actions based on model values set by <f:viewParam> during update model values phase. Namely, they are not available at the moment the @PostConstruct runs. In JSF 2.0/2.1, this tag didn't exist and you have to use the preRenderView workaround.

> If the backing bean is @RequestScoped, do they effectively do the exact same thing? (and so then it is up to developer choice? (@PostConstruct seems "cleaner").

No, they do definitely not effectively do the same thing. The @PostConstruct is intented to perform actions directly after bean's construction and setting of all injected dependencies and managed properties such as @EJB, @Inject, @ManagedProperty, etc. Namely, the injected dependencies are not available inside the bean's constructor. This will thus run only once per view, session or application when the bean is view, session or application scoped. The <f:viewAction> is by default only invoked on initial GET request, but can via onPostback="true" attribute be configured to be invoked on postback requests as well. The preRenderView event is invoked on every HTTP request (yes, this also includes ajax requests!).

Summarized, use @PostConstruct if you want to perform actions on injected dependencies and managed properties which are set by @EJB, @Inject, @ManagedProperty, etc during bean's construction. Use <f:viewAction> if you also want to perform actions on properties set by <f:viewParam>. If you're still on JSF 2.0/2.1, use preRenderView instead of <f:viewAction>. You can if necessary add a check on FacesContext#isPostback() to perform the preRenderView action on initial request only.

See also:

• https://stackoverflow.com/questions/6377798
• https://stackoverflow.com/questions/4888942
• https://stackoverflow.com/questions/8506033

Do you need to initialize managed bean's properties? --> Then, use @PostConstruct Otherwise, do you need to work with params passed from other view? --> Then, use "preRenderView"