public synchronized  void afterPhase(PhaseEvent event) 
{
    // ---------------------------------------------- Methods From PhaseListener
        if (!postInitCompleted) {
            LifecycleFactory factory = (LifecycleFactory)
                  FactoryFinder.getFactory(FactoryFinder.LIFECYCLE_FACTORY);
            // remove ourselves from the list of listeners maintained by
            // the lifecycle instances
            for(Iterator< String > i = factory.getLifecycleIds(); i.hasNext(); ) {
                Lifecycle lifecycle = factory.getLifecycle(i.next());
                lifecycle.removePhaseListener(this);
            }
            postInitCompleted = true;
        }
}

Handle a notification that the processing for a particular phase has just been completed.

When invoked, this phase listener will remove itself as a registered PhaseListener with all Lifecycle instances.

 public synchronized  void beforePhase(PhaseEvent event) 
{
        if (!preInitCompleted) {
            ApplicationAssociate associate =
                 ApplicationAssociate.getInstance(
                      FacesContext.getCurrentInstance().getExternalContext());
            associate.setRequestServiced();
            populateFacesELResolverForJsp(event.getFacesContext());
            preInitCompleted = true;
        }
}

Handle a notification that the processing for a particular phase of the request processing lifecycle is about to begin.

The implementation of this method currently calls through to #populateFacesELResolverForJsp(javax.faces.context.FacesContext) .

 public PhaseId getPhaseId() 
{
        return PhaseId.ANY_PHASE;
}

Return the identifier of the request processing phase during which this listener is interested in processing javax.faces.event.PhaseEvent events. Legal values are the singleton instances defined by the javax.faces.event.PhaseId class, including PhaseId.ANY_PHASE to indicate an interest in being notified for all standard phases.

We return PhaseId.ANY_PHASE.

 protected  void populateFacesELResolverForJsp(FacesContext context) 
{
        ApplicationAssociate appAssociate =
              ApplicationAssociate.getInstance(context.getExternalContext());
        CompositeELResolver compositeELResolverForJsp =
              appAssociate.getFacesELResolverForJsp();
        if (compositeELResolverForJsp == null) {
            if (LOGGER.isLoggable(Level.INFO)) {
                LOGGER.log(Level.INFO,
                           "jsf.lifecycle.initphaselistener.resolvers_not_registered",
                           new Object[] { appAssociate.getContextName() });
            }
            return;
        }
        ELUtils.buildJSPResolver(compositeELResolverForJsp, appAssociate);
        // somewhat of a hack, but since we're here, trigger the creation
        // of the FacesResolvers as well by calling Application.getELResolver()
        // to avoid a sync block on that method.
        context.getApplication().getELResolver();
        if (LOGGER.isLoggable(Level.FINE)) {
            LOGGER.log(Level.FINE,
                       "jsf.lifecycle.initphaselistener.resolvers_registered",
                       new Object[] { appAssociate.getContextName() });
        }
}

Populate the FacesCompositeELResolver stack registered with JSP if a request is being processed for the very first time. At the application initialiazation time, an empty CompositeELResolver is registered with JSP because ELResolvers can be added until the first request is serviced.