| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.myfaces.view.facelets; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| import javax.faces.application.Application; |
| import javax.faces.application.NavigationHandler; |
| import javax.faces.application.ProjectStage; |
| import javax.faces.application.ResourceDependency; |
| import javax.faces.application.ViewHandler; |
| import javax.faces.component.UIComponent; |
| import javax.faces.component.UIViewRoot; |
| import javax.faces.context.FacesContext; |
| import javax.faces.event.PhaseId; |
| import javax.faces.view.StateManagementStrategy; |
| import javax.faces.view.ViewDeclarationLanguage; |
| import org.apache.myfaces.application.StateManagerImpl; |
| import org.apache.myfaces.component.ComponentResourceContainer; |
| import org.apache.myfaces.context.RequestViewContext; |
| import org.apache.myfaces.context.RequestViewMetadata; |
| import org.apache.myfaces.lifecycle.RestoreViewSupport; |
| import org.apache.myfaces.config.MyfacesConfig; |
| import org.apache.myfaces.util.WebConfigParamUtils; |
| import org.apache.myfaces.view.facelets.impl.FaceletCompositionContextImpl; |
| import org.apache.myfaces.view.facelets.pool.ViewPool; |
| import org.apache.myfaces.view.facelets.pool.ViewPoolFactory; |
| import org.apache.myfaces.view.facelets.pool.ViewEntry; |
| import org.apache.myfaces.view.facelets.pool.ViewStructureMetadata; |
| import org.apache.myfaces.view.facelets.pool.impl.ViewPoolFactoryImpl; |
| import org.apache.myfaces.view.facelets.tag.jsf.ComponentSupport; |
| import org.apache.myfaces.view.facelets.tag.jsf.FaceletState; |
| |
| /** |
| * This class is reponsible for all processing tasks related to the view pool. |
| * |
| * For enable the pool only for a subset of your views, you can |
| * add an entry inside faces-config.xml file like this: |
| * <pre> |
| * {@code |
| * <faces-config-extension> |
| * <view-pool-mapping> |
| * <url-pattern>/*</url-pattern> |
| * <parameter> |
| * <name>org.apache.myfaces.VIEW_POOL_MAX_POOL_SIZE</name> |
| * <value>5</value> |
| * </parameter> |
| * </view-pool-mapping> |
| * </faces-config-extension> |
| * } |
| * </pre> |
| * |
| * @author Leonardo Uribe |
| */ |
| public class ViewPoolProcessor |
| { |
| /** |
| * Used to hold the view pool processor instance on the application map. |
| * A ViewPoolProcessor is only accessible if the view pool has been |
| * enabled for the whole application (using a web config parameter) or |
| * partially (an <view-pool-mapping> entry inside <faces-config-extension>). |
| */ |
| private final static String INSTANCE = "oam.ViewPoolProcessor"; |
| |
| /** |
| * UIViewRoot attribute to enable/disable the view for use pooling. |
| */ |
| public final static String ENABLE_VIEW_POOL = "oamEnableViewPool"; |
| |
| /** |
| * Flag that indicates to the StateManagementStrategy that no state needs |
| * to be stored and we are using saveState() to dispose the view and store it |
| * into the pool directly. |
| */ |
| public final static String FORCE_HARD_RESET = "oam.ViewPool.forceHardReset"; |
| |
| /** |
| * Flag to indicate that dispose this view on navigation is valid. |
| */ |
| public final static String DISPOSE_VIEW_NAVIGATION = "oam.ViewPool.disposeViewOnNavigation"; |
| |
| /** |
| * Attribute of UIViewRoot that indicates if a soft (1) or hard(2) |
| * (reset and check) reset is required in the call to saveState(). |
| */ |
| public final static String RESET_SAVE_STATE_MODE_KEY ="oam.view.resetSaveStateMode"; |
| |
| /** |
| * Indicates no reset should be done on this state saving |
| */ |
| public static final Integer RESET_MODE_OFF = 0; |
| |
| /** |
| * Indicates a soft reset should be done when saveState(...) is performed, |
| * which means all transient state should be cleared but the delta state |
| * should not be destroyed in the process. |
| */ |
| public static final Integer RESET_MODE_SOFT = 1; |
| |
| /** |
| * Indicates a hard reset should be done when saveState(...) is performed, |
| * which means all transient and delta state should be cleared, destroying |
| * all existing state in the process. If something cannot be reseted, the |
| * state should return non null, so the algorithm can remove the component |
| * from the tree and mark the tree as partial (requires refresh before |
| * reuse). |
| */ |
| public static final Integer RESET_MODE_HARD = 2; |
| |
| /** |
| * Param used to indicate a "deferred navigation" needs to be done. To allow the view pool to |
| * dispose the view properly (and reuse it later), it is necessary to ensure the view is not |
| * being used at the moment. If the navigation call occur inside an action listener, the current |
| * view is being used and cannot be disposed (because it conflicts with hard/soft reset). This |
| * extension allows to call handleNavigation() before end invoke application phase, but after |
| * traverse the component tree. |
| */ |
| public static final String INVOKE_DEFERRED_NAVIGATION = "oam.invoke.navigation"; |
| |
| private ViewPoolFactory viewPoolFactory; |
| private RestoreViewSupport restoreViewSupport; |
| |
| public ViewPoolProcessor(FacesContext context) |
| { |
| viewPoolFactory = new ViewPoolFactoryImpl(context); |
| restoreViewSupport = new RestoreViewSupport(context); |
| } |
| |
| public static ViewPoolProcessor getInstance(FacesContext context) |
| { |
| return (ViewPoolProcessor) context.getExternalContext().getApplicationMap().get(INSTANCE); |
| } |
| |
| /** |
| * This method should be called at startup to decide if a view processor should be |
| * provided or not to the runtime. |
| * |
| * @param context |
| */ |
| public static void initialize(FacesContext context) |
| { |
| if (context.isProjectStage(ProjectStage.Production)) |
| { |
| MyfacesConfig myfacesConfig = MyfacesConfig.getCurrentInstance(context); |
| |
| boolean initialize = true; |
| |
| if (myfacesConfig.getELExpressionCacheMode() != ELExpressionCacheMode.alwaysRecompile) |
| { |
| Logger.getLogger(ViewPoolProcessor.class.getName()).log(Level.INFO, |
| MyfacesConfig.CACHE_EL_EXPRESSIONS |
| + " web config parameter is set to \"" |
| + ((myfacesConfig.getELExpressionCacheMode() == null) |
| ? "none" : myfacesConfig.getELExpressionCacheMode()) |
| + "\". To enable view pooling this param" |
| + " must be set to \"alwaysRecompile\". View Pooling disabled."); |
| initialize = false; |
| } |
| |
| long refreshPeriod = WebConfigParamUtils.getLongInitParameter(context.getExternalContext(), |
| ViewHandler.FACELETS_REFRESH_PERIOD_PARAM_NAME, |
| FaceletViewDeclarationLanguage.DEFAULT_REFRESH_PERIOD_PRODUCTION); |
| |
| if (refreshPeriod != -1) |
| { |
| Logger.getLogger(ViewPoolProcessor.class.getName()).log( |
| Level.INFO, ViewHandler.FACELETS_REFRESH_PERIOD_PARAM_NAME + |
| " web config parameter is set to \"" + Long.toString(refreshPeriod) + |
| "\". To enable view pooling this param"+ |
| " must be set to \"-1\". View Pooling disabled."); |
| initialize = false; |
| } |
| |
| if (myfacesConfig.isStrictJsf2FaceletsCompatibility()) |
| { |
| Logger.getLogger(ViewPoolProcessor.class.getName()).log( |
| Level.INFO, MyfacesConfig.STRICT_JSF_2_FACELETS_COMPATIBILITY + |
| " web config parameter is set to \"" + "true" + |
| "\". To enable view pooling this param "+ |
| " must be set to \"false\". View Pooling disabled."); |
| initialize = false; |
| } |
| |
| if (initialize) |
| { |
| ViewPoolProcessor processor = new ViewPoolProcessor(context); |
| context.getExternalContext(). |
| getApplicationMap().put(INSTANCE, processor); |
| } |
| } |
| } |
| |
| public ViewPool getViewPool(FacesContext context, UIViewRoot root) |
| { |
| if (root.isTransient()) |
| { |
| // Stateless views cannot be pooled, because we are reusing |
| // state saving algorithm for that. |
| return null; |
| } |
| |
| Boolean enableViewPool = (Boolean) root.getAttributes().get(ViewPoolProcessor.ENABLE_VIEW_POOL); |
| if (enableViewPool != null && !Boolean.TRUE.equals(enableViewPool)) |
| { |
| // view pool not enabled for this view. |
| return null; |
| } |
| else |
| { |
| return viewPoolFactory.getViewPool(context, root); |
| } |
| } |
| |
| public boolean isViewPoolEnabledForThisView(FacesContext context, UIViewRoot root) |
| { |
| if (root.isTransient()) |
| { |
| // Stateless views cannot be pooled, because we are reusing |
| // state saving algorithm for that. |
| return false; |
| } |
| |
| Boolean enableViewPool = (Boolean) root.getAttributes().get(ViewPoolProcessor.ENABLE_VIEW_POOL); |
| if (enableViewPool != null) |
| { |
| return enableViewPool; |
| } |
| |
| ViewPool viewPool = getViewPool(context, root); |
| if (viewPool != null) |
| { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| public boolean isViewPoolStrategyAllowedForThisView(FacesContext context, UIViewRoot root) |
| { |
| // Check if the viewId is not null. |
| if (root.getViewId() == null) |
| { |
| return false; |
| } |
| if (root.isTransient()) |
| { |
| // Stateless views cannot be pooled, because we are reusing |
| // state saving algorithm for that. |
| return false; |
| } |
| |
| // Check if the view is enabled or not for use pooling |
| if (!isViewPoolEnabledForThisView(context, root)) |
| { |
| return false; |
| } |
| |
| // Check if the vdl is using PSS on this view (has a vdl and that vdl is facelets) |
| ViewDeclarationLanguage vdl = context.getApplication().getViewHandler(). |
| getViewDeclarationLanguage(context, root.getViewId()); |
| if (vdl == null) |
| { |
| return false; |
| } |
| else if (!ViewDeclarationLanguage.FACELETS_VIEW_DECLARATION_LANGUAGE_ID.equals(vdl.getId())) |
| { |
| return false; |
| } |
| |
| if (vdl.getStateManagementStrategy(context, root.getViewId()) == null) |
| { |
| return false; |
| } |
| return true; |
| } |
| |
| public void setViewPoolDisabledOnThisView(FacesContext context, UIViewRoot root, boolean value) |
| { |
| root.getAttributes().put(ViewPoolProcessor.ENABLE_VIEW_POOL, !value); |
| } |
| |
| /** |
| * Takes the newView and restore the state taken as base the provided ViewEntry, |
| * and then move all child components from oldView to newView, to finally obtain |
| * a clean component tree. |
| * |
| * @param context |
| * @param newView |
| * @param entry |
| */ |
| public void cloneAndRestoreView(FacesContext context, UIViewRoot newView, |
| ViewEntry entry, ViewStructureMetadata metadata) |
| { |
| UIViewRoot oldView = entry.getViewRoot(); |
| // retrieveViewRootInitialState(context, oldView) |
| Object viewState = metadata.getViewRootState(); |
| Object newViewState; |
| UIComponent metadataFacet = newView.getFacet(UIViewRoot.METADATA_FACET_NAME); |
| if (viewState == null) |
| { |
| // (Optional, it should be always metadata) |
| oldView.clearInitialState(); |
| viewState = oldView.saveState(context); |
| } |
| Map<String, Object> viewScopeMap = newView.getViewMap(false); |
| if (viewScopeMap != null && !viewScopeMap.isEmpty()) |
| { |
| newViewState = newView.saveState(context); |
| } |
| else |
| { |
| newViewState = null; |
| } |
| |
| boolean oldProcessingEvents = context.isProcessingEvents(); |
| context.setProcessingEvents(false); |
| try |
| { |
| if (oldView.getFacetCount() > 0) |
| { |
| List<String> facetKeys = new ArrayList<>(oldView.getFacets().keySet()); |
| |
| for (String facetKey : facetKeys) |
| { |
| //context.setProcessingEvents(false); |
| if (metadataFacet != null && UIViewRoot.METADATA_FACET_NAME.equals(facetKey) && |
| !PhaseId.RESTORE_VIEW.equals(context.getCurrentPhaseId())) |
| { |
| // Metadata facet is special, it is created when ViewHandler.createView(...) is |
| // called, so it shouldn't be taken from the oldView, otherwise the state |
| // will be lost. Instead reuse it and discard the one in oldView. |
| // But on restore view phase, use the old one, because the new one does not |
| // have initial state marked. |
| newView.getFacets().put(facetKey, metadataFacet); |
| } |
| else |
| { |
| UIComponent facet = oldView.getFacets().remove(facetKey); |
| //context.setProcessingEvents(true); |
| newView.getFacets().put(facetKey, facet); |
| } |
| } |
| } |
| if (oldView.getChildCount() > 0) |
| { |
| for (Iterator<UIComponent> it = oldView.getChildren().iterator(); it.hasNext();) |
| { |
| //context.setProcessingEvents(false); |
| UIComponent c = it.next(); |
| it.remove(); |
| //context.setProcessingEvents(true); |
| newView.getChildren().add(c); |
| } |
| } |
| |
| // Restore the newView as saved just before markInitialState() call |
| newView.restoreState(context, viewState); |
| newView.markInitialState(); |
| |
| if (!PhaseId.RESTORE_VIEW.equals(context.getCurrentPhaseId())) |
| { |
| // Restore bindings like in restore view phase, because in this case, |
| // bindings needs to be set (Application.createComponent is not called!). |
| restoreViewSupport.processComponentBinding(context, newView); |
| |
| // Restore view scope map if necessary |
| if (viewScopeMap != null && !viewScopeMap.isEmpty()) |
| { |
| Map<String, Object> newViewScopeMap = newView.getViewMap(false); |
| if (newViewScopeMap == null) |
| { |
| newView.restoreViewScopeState(context, newViewState); |
| } |
| else |
| { |
| // Should theoretically not happen, because when a pooled static view |
| // is saved, the view scope map is skipped, otherwise it could be a |
| // leak. Anyway, we let this code here that overrides the values from |
| // the original map. |
| for (Map.Entry<String, Object> entry2 : viewScopeMap.entrySet()) |
| { |
| newViewScopeMap.put(entry2.getKey(), entry2.getValue()); |
| } |
| } |
| } |
| } |
| |
| // Update request view metadata to ensure resource list is restored as when the |
| // view was built on the first time. This ensures correct calculation of added |
| // resources by dynamic behavior. |
| RequestViewContext rcv = RequestViewContext.getCurrentInstance(context, newView, false); |
| if (rcv != null) |
| { |
| rcv.setRequestViewMetadata(metadata.getRequestViewMetadata().cloneInstance()); |
| } |
| else |
| { |
| RequestViewContext.setCurrentInstance(context, newView, |
| RequestViewContext.newInstance(metadata.getRequestViewMetadata().cloneInstance())); |
| } |
| } |
| finally |
| { |
| context.setProcessingEvents(oldProcessingEvents); |
| } |
| } |
| |
| public void storeViewStructureMetadata(FacesContext context, UIViewRoot root) |
| { |
| ViewPool viewPool = getViewPool(context, root); |
| if (viewPool != null) |
| { |
| FaceletState faceletState = (FaceletState) root.getAttributes().get( |
| ComponentSupport.FACELET_STATE_INSTANCE); |
| boolean isDynamic = faceletState != null ? faceletState.isDynamic() : false; |
| if (!isDynamic) |
| { |
| viewPool.storeStaticViewStructureMetadata(context, root, faceletState); |
| } |
| else |
| { |
| viewPool.storeDynamicViewStructureMetadata(context, root, faceletState); |
| } |
| } |
| } |
| |
| public ViewStructureMetadata retrieveViewStructureMetadata(FacesContext context, UIViewRoot root) |
| { |
| ViewPool viewPool = getViewPool(context, root); |
| if (viewPool != null) |
| { |
| FaceletState faceletState = (FaceletState) root.getAttributes().get( |
| ComponentSupport.FACELET_STATE_INSTANCE); |
| boolean isDynamic = faceletState != null ? faceletState.isDynamic() : false; |
| if (!isDynamic) |
| { |
| return viewPool.retrieveStaticViewStructureMetadata(context, root); |
| } |
| else |
| { |
| return viewPool.retrieveDynamicViewStructureMetadata(context, root, faceletState); |
| } |
| } |
| return null; |
| } |
| |
| public void pushResetableView(FacesContext context, UIViewRoot view, FaceletState faceletViewState) |
| { |
| ViewPool viewPool = getViewPool(context, view); |
| if (viewPool != null) |
| { |
| boolean isDynamic = faceletViewState != null ? faceletViewState.isDynamic() : false; |
| if (!isDynamic) |
| { |
| clearTransientAndNonFaceletComponentsForStaticView(context, view); |
| viewPool.pushStaticStructureView(context, view); |
| } |
| else |
| { |
| ViewStructureMetadata viewStructureMetadata = viewPool.retrieveDynamicViewStructureMetadata( |
| context, view, faceletViewState); |
| if (viewStructureMetadata != null) |
| { |
| clearTransientAndNonFaceletComponentsForDynamicView(context, view, viewStructureMetadata); |
| viewPool.pushDynamicStructureView(context, view, faceletViewState); |
| } |
| } |
| } |
| } |
| |
| public void pushPartialView(FacesContext context, UIViewRoot view, FaceletState faceletViewState, int count) |
| { |
| ViewPool viewPool = getViewPool(context, view); |
| |
| if (viewPool != null && viewPool.isWorthToRecycleThisView(context, view)) |
| { |
| ViewStructureMetadata viewStructureMetadata = null; |
| if (faceletViewState == null) |
| { |
| viewStructureMetadata = viewPool.retrieveStaticViewStructureMetadata(context, view); |
| } |
| else |
| { |
| viewStructureMetadata = viewPool.retrieveDynamicViewStructureMetadata( |
| context, view, faceletViewState); |
| } |
| if (viewStructureMetadata != null) |
| { |
| ClearPartialTreeContext ptc = new ClearPartialTreeContext(); |
| // add partial structure view to the map. |
| clearTransientAndRemoveNonResetableComponents(context, ptc, view, viewStructureMetadata); |
| int reusableCount = ptc.getCount(); |
| float factor = ((float) reusableCount) / ((float) count); |
| if (factor > 0.3f) |
| { |
| viewPool.pushPartialStructureView(context, view); |
| } |
| } |
| } |
| } |
| |
| protected void clearTransientAndNonFaceletComponentsForStaticView(FacesContext context, UIViewRoot root) |
| { |
| // In a static view, clear components that are both transient and non bound to any facelet tag handler |
| // is quite simple. Since the structure of the view is static, there is no need to check component resources. |
| clearTransientAndNonFaceletComponents(context, root); |
| } |
| |
| public void clearTransientAndNonFaceletComponentsForDynamicView(final FacesContext context, |
| final UIViewRoot root, final ViewStructureMetadata viewStructureMetadata) |
| { |
| //Scan children |
| int childCount = root.getChildCount(); |
| if (childCount > 0) |
| { |
| for (int i = 0; i < childCount; i++) |
| { |
| UIComponent child = root.getChildren().get(i); |
| if (child != null && child.isTransient() && |
| child.getAttributes().get(ComponentSupport.MARK_CREATED) == null) |
| { |
| root.getChildren().remove(i); |
| i--; |
| childCount--; |
| } |
| else |
| { |
| if (child.getChildCount() > 0 || !child.getFacets().isEmpty()) |
| { |
| clearTransientAndNonFaceletComponents(context, child); |
| } |
| } |
| } |
| } |
| |
| clearTransientAndNonFaceletComponentsForDynamicViewUIViewRootFacets( |
| context, root, viewStructureMetadata); |
| } |
| |
| private void clearTransientAndNonFaceletComponentsForDynamicViewUIViewRootFacets(final FacesContext context, |
| final UIViewRoot root, ViewStructureMetadata viewStructureMetadata) |
| { |
| |
| //Scan facets |
| if (root.getFacetCount() > 0) |
| { |
| Map<String, UIComponent> facets = root.getFacets(); |
| for (Iterator<UIComponent> itr = facets.values().iterator(); itr.hasNext();) |
| { |
| UIComponent fc = itr.next(); |
| if (fc != null && !(fc instanceof ComponentResourceContainer)) |
| { |
| if ( fc.isTransient() && |
| fc.getAttributes().get(ComponentSupport.MARK_CREATED) == null) |
| { |
| itr.remove(); |
| } |
| else |
| { |
| if (fc.getChildCount() > 0 || !fc.getFacets().isEmpty()) |
| { |
| clearTransientAndNonFaceletComponents(context, fc); |
| } |
| } |
| } |
| else if (fc != null) |
| { |
| // In a facet which is a ComponentResourceContainer instance, |
| // we need to check these two cases: |
| // 1. Resources relocated by facelets |
| // 2. Resources created by effect of a @ResourceDependency annotation |
| if (fc.getId() != null |
| && fc.getId().startsWith(FaceletCompositionContextImpl.JAVAX_FACES_LOCATION_PREFIX)) |
| { |
| String target = fc.getId().substring( |
| FaceletCompositionContextImpl.JAVAX_FACES_LOCATION_PREFIX.length()); |
| Map<String, List<ResourceDependency>> addedResources = |
| viewStructureMetadata.getRequestViewMetadata(). |
| getResourceDependencyAnnotations(context); |
| List<ResourceDependency> resourceDependencyList = (addedResources != null) ? |
| addedResources.get(target) : null; |
| |
| clearComponentResourceContainer(context, fc, resourceDependencyList); |
| } |
| } |
| } |
| } |
| } |
| |
| private void clearComponentResourceContainer(final FacesContext context, UIComponent component, |
| List<ResourceDependency> resourceDependencyList) |
| { |
| //Scan children |
| int childCount = component.getChildCount(); |
| if (childCount > 0) |
| { |
| for (int i = 0; i < childCount; i++) |
| { |
| UIComponent child = component.getChildren().get(i); |
| String id = (String) child.getAttributes().get(ComponentSupport.MARK_CREATED); |
| if (child != null && child.isTransient() && id == null) |
| { |
| //Remove both transient not facelets bound components |
| component.getChildren().remove(i); |
| i--; |
| childCount--; |
| } |
| else if (id != null) |
| { |
| // If it has an id set, it is a facelet component resource. |
| // The refresh algorithm take care of the cleanup. |
| } |
| /* |
| else if (!child.isTransient() && id != null && !faceletResources.contains(id)) |
| { |
| // check if the resource has a facelet tag in this "dynamic state", if not |
| // remove it. Really leave a component resource does not harm, but |
| // the objective is make this view as close as when if it is built as new. |
| component.getChildren().remove(i); |
| i--; |
| childCount--; |
| }*/ |
| else |
| { |
| // Check if the component instance was created using a @ResourceDependency annotation |
| Object[] rdk = (Object[]) child.getAttributes().get(RequestViewMetadata.RESOURCE_DEPENDENCY_KEY); |
| if (rdk != null) |
| { |
| boolean found = false; |
| String library = (String) rdk[0]; |
| String name = (String) rdk[1]; |
| if (resourceDependencyList != null) |
| { |
| for (ResourceDependency resource : resourceDependencyList) |
| { |
| if (library == null && resource.library() == null) |
| { |
| if (name != null && name.equals(resource.name())) |
| { |
| found = true; |
| break; |
| } |
| } |
| else |
| { |
| if (library != null && library.equals(resource.library()) && |
| name != null && name.equals(resource.name()) ) |
| { |
| found = true; |
| break; |
| } |
| } |
| } |
| } |
| if (!found) |
| { |
| //Remove it, because for this dynamic state it it does not exists. |
| component.getChildren().remove(i); |
| i--; |
| childCount--; |
| } |
| // If found just leave it. |
| } |
| else |
| { |
| if (child.getChildCount() > 0 || !child.getFacets().isEmpty()) |
| { |
| clearTransientAndNonFaceletComponents(context, child); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Clear all transient components not created by facelets algorithm. In this way, |
| * we ensure the component tree does not have any changes done after markInitialState. |
| * |
| * @param context |
| * @param component |
| */ |
| private void clearTransientAndNonFaceletComponents(final FacesContext context, final UIComponent component) |
| { |
| //Scan children |
| int childCount = component.getChildCount(); |
| if (childCount > 0) |
| { |
| for (int i = 0; i < childCount; i++) |
| { |
| UIComponent child = component.getChildren().get(i); |
| if (child != null && child.isTransient() && |
| child.getAttributes().get(ComponentSupport.MARK_CREATED) == null) |
| { |
| component.getChildren().remove(i); |
| i--; |
| childCount--; |
| } |
| else |
| { |
| if (child.getChildCount() > 0 || !child.getFacets().isEmpty()) |
| { |
| clearTransientAndNonFaceletComponents(context, child); |
| } |
| } |
| } |
| } |
| |
| //Scan facets |
| if (component.getFacetCount() > 0) |
| { |
| Map<String, UIComponent> facets = component.getFacets(); |
| for (Iterator<UIComponent> itr = facets.values().iterator(); itr.hasNext();) |
| { |
| UIComponent fc = itr.next(); |
| if (fc != null && fc.isTransient() && |
| fc.getAttributes().get(ComponentSupport.MARK_CREATED) == null) |
| { |
| itr.remove(); |
| } |
| else |
| { |
| if (fc.getChildCount() > 0 || !fc.getFacets().isEmpty()) |
| { |
| clearTransientAndNonFaceletComponents(context, fc); |
| } |
| } |
| } |
| } |
| } |
| |
| private void clearTransientAndRemoveNonResetableComponents(final FacesContext context, |
| final ClearPartialTreeContext ptc, final UIViewRoot root, |
| ViewStructureMetadata viewStructureMetadata) |
| { |
| //Scan children |
| int childCount = root.getChildCount(); |
| |
| try |
| { |
| root.getAttributes().put(ViewPoolProcessor.RESET_SAVE_STATE_MODE_KEY, ViewPoolProcessor.RESET_MODE_HARD); |
| if (childCount > 0) |
| { |
| for (int i = 0; i < childCount; i++) |
| { |
| UIComponent child = root.getChildren().get(i); |
| boolean containsFaceletId = child.getAttributes().containsKey(ComponentSupport.MARK_CREATED); |
| if (child != null && child.isTransient() && !containsFaceletId) |
| { |
| //Transient and not bound to facelets tag, remove it!. |
| root.getChildren().remove(i); |
| i--; |
| childCount--; |
| } |
| else |
| { |
| if (child.getAttributes().containsKey(ComponentSupport.COMPONENT_ADDED_BY_HANDLER_MARKER)) |
| { |
| //Dynamically added or moved, remove it! |
| root.getChildren().remove(i); |
| i--; |
| childCount--; |
| |
| } |
| else if (containsFaceletId || |
| child.getAttributes().containsKey(ComponentSupport.COMPONENT_ADDED_BY_HANDLER_MARKER)) |
| { |
| // Bound to a facelet tag or created by facelets, we have two options: |
| // 1. If is not transient, check its state and try to clear it, if fails remove it |
| // 2. If is transient, assume stateless, continue. |
| if (!child.isTransient()) |
| { |
| // Remember that hard reset is already enabled. |
| Object state = child.saveState(context); |
| if (state == null) |
| { |
| if (child.getChildCount() > 0 || !child.getFacets().isEmpty()) |
| { |
| clearTransientAndRemoveNonResetableComponents(context, ptc, child); |
| } |
| ptc.incrementCount(); |
| } |
| else |
| { |
| root.getChildren().remove(i); |
| i--; |
| childCount--; |
| } |
| } |
| else |
| { |
| ptc.incrementCount(); |
| } |
| } |
| else |
| { |
| // Non facelets component, remove it!. |
| root.getChildren().remove(i); |
| i--; |
| childCount--; |
| } |
| } |
| } |
| } |
| |
| clearTransientAndNonFaceletComponentsForDynamicViewUIViewRootFacets( |
| context, root, viewStructureMetadata); |
| } |
| finally |
| { |
| root.getAttributes().put(ViewPoolProcessor.RESET_SAVE_STATE_MODE_KEY, |
| ViewPoolProcessor.RESET_MODE_OFF); |
| } |
| } |
| |
| private void clearTransientAndRemoveNonResetableComponents(final FacesContext context, |
| final ClearPartialTreeContext ptc, final UIComponent component) |
| { |
| //Scan children |
| int childCount = component.getChildCount(); |
| if (childCount > 0) |
| { |
| for (int i = 0; i < childCount; i++) |
| { |
| UIComponent child = component.getChildren().get(i); |
| boolean containsFaceletId = child.getAttributes().containsKey(ComponentSupport.MARK_CREATED); |
| if (child.isTransient() && !containsFaceletId) |
| { |
| //Transient and not bound to facelets tag, remove it!. |
| component.getChildren().remove(i); |
| i--; |
| childCount--; |
| } |
| else |
| { |
| if (child.getAttributes().containsKey(ComponentSupport.COMPONENT_ADDED_BY_HANDLER_MARKER)) |
| { |
| //Dynamically added or moved, remove it! |
| component.getChildren().remove(i); |
| i--; |
| childCount--; |
| |
| } |
| else if (containsFaceletId || |
| child.getAttributes().containsKey(ComponentSupport.COMPONENT_ADDED_BY_HANDLER_MARKER)) |
| { |
| // Bound to a facelet tag or created by facelets, we have two options: |
| // 1. If is not transient, check its state and try to clear it, if fails remove it |
| // 2. If is transient, assume stateless, continue. |
| if (!child.isTransient()) |
| { |
| // Remember that hard reset is already enabled. |
| Object state = child.saveState(context); |
| if (state == null) |
| { |
| if (child.getChildCount() > 0 || !child.getFacets().isEmpty()) |
| { |
| clearTransientAndRemoveNonResetableComponents(context, ptc, child); |
| } |
| ptc.incrementCount(); |
| } |
| else |
| { |
| component.getChildren().remove(i); |
| i--; |
| childCount--; |
| } |
| } |
| else |
| { |
| ptc.incrementCount(); |
| } |
| } |
| else |
| { |
| // Non facelets component, remove it!. |
| component.getChildren().remove(i); |
| i--; |
| childCount--; |
| } |
| } |
| } |
| } |
| |
| //Scan facets |
| if (component.getFacetCount() > 0) |
| { |
| Map<String, UIComponent> facets = component.getFacets(); |
| for (Iterator<UIComponent> itr = facets.values().iterator(); itr.hasNext();) |
| { |
| UIComponent fc = itr.next(); |
| boolean containsFaceletId = fc.getAttributes().containsKey(ComponentSupport.MARK_CREATED); |
| if (fc.isTransient() && !containsFaceletId) |
| { |
| //Transient and not bound to facelets tag, remove it!. |
| itr.remove(); |
| } |
| else |
| { |
| if (fc.getAttributes().containsKey(ComponentSupport.COMPONENT_ADDED_BY_HANDLER_MARKER)) |
| { |
| //Dynamically added or moved, remove it! |
| itr.remove(); |
| |
| } |
| else if (containsFaceletId || |
| fc.getAttributes().containsKey(ComponentSupport.COMPONENT_ADDED_BY_HANDLER_MARKER)) |
| { |
| // Bound to a facelet tag or created by facelets, we have two options: |
| // 1. If is not transient, check its state and try to clear it, if fails remove it |
| // 2. If is transient, assume stateless, continue. |
| if (!fc.isTransient()) |
| { |
| // Remember that hard reset is already enabled. |
| Object state = fc.saveState(context); |
| if (state == null) |
| { |
| if (fc.getChildCount() > 0 || !fc.getFacets().isEmpty()) |
| { |
| clearTransientAndRemoveNonResetableComponents(context, ptc, fc); |
| } |
| ptc.incrementCount(); |
| } |
| else |
| { |
| itr.remove(); |
| } |
| } |
| else |
| { |
| ptc.incrementCount(); |
| } |
| } |
| else |
| { |
| // Non facelets component, remove it!. |
| itr.remove(); |
| } |
| } |
| } |
| } |
| } |
| |
| public void processDeferredNavigation(FacesContext facesContext) |
| { |
| Object[] command = (Object[]) facesContext.getAttributes().get( |
| ViewPoolProcessor.INVOKE_DEFERRED_NAVIGATION); |
| if (command != null) |
| { |
| try |
| { |
| facesContext.getAttributes().put(ViewPoolProcessor.DISPOSE_VIEW_NAVIGATION, Boolean.TRUE); |
| NavigationHandler navigationHandler = facesContext.getApplication().getNavigationHandler(); |
| if (command.length == 3) |
| { |
| navigationHandler.handleNavigation(facesContext, (String) command[0], (String) command[1], |
| (String) command[2]); |
| } |
| else |
| { |
| navigationHandler.handleNavigation(facesContext, (String) command[0], (String) command[1]); |
| } |
| //Render Response if needed |
| facesContext.renderResponse(); |
| facesContext.getAttributes().remove(ViewPoolProcessor.INVOKE_DEFERRED_NAVIGATION); |
| } |
| finally |
| { |
| facesContext.getAttributes().remove(ViewPoolProcessor.DISPOSE_VIEW_NAVIGATION); |
| } |
| } |
| } |
| |
| public void disposeView(FacesContext facesContext, UIViewRoot root) |
| { |
| if (root == null) |
| { |
| return; |
| } |
| |
| String viewId = root.getViewId(); |
| if (viewId == null) |
| { |
| return; |
| } |
| Application app = facesContext.getApplication(); |
| if (app == null) |
| { |
| return; |
| } |
| ViewHandler viewHandler = app.getViewHandler(); |
| if (viewHandler == null) |
| { |
| return; |
| } |
| |
| if (Boolean.TRUE.equals(facesContext.getAttributes().get(ViewPoolProcessor.DISPOSE_VIEW_NAVIGATION))) |
| { |
| ViewDeclarationLanguage vdl = facesContext.getApplication(). |
| getViewHandler().getViewDeclarationLanguage( |
| facesContext, root.getViewId()); |
| |
| if (vdl != null && ViewDeclarationLanguage.FACELETS_VIEW_DECLARATION_LANGUAGE_ID.equals(vdl.getId())) |
| { |
| StateManagementStrategy sms = vdl.getStateManagementStrategy(facesContext, root.getId()); |
| if (sms != null) |
| { |
| // Force indirectly to store the map in the pool |
| facesContext.getAttributes().put(ViewPoolProcessor.FORCE_HARD_RESET, Boolean.TRUE); |
| |
| try |
| { |
| Object state = sms.saveView(facesContext); |
| } |
| finally |
| { |
| facesContext.getAttributes().remove(ViewPoolProcessor.FORCE_HARD_RESET); |
| } |
| |
| // Clear the calculated value from the application map |
| facesContext.getAttributes().remove(StateManagerImpl.SERIALIZED_VIEW_REQUEST_ATTR); |
| } |
| } |
| } |
| } |
| |
| private static class ClearPartialTreeContext |
| { |
| private int count; |
| |
| public ClearPartialTreeContext() |
| { |
| count = 0; |
| } |
| |
| public int getCount() |
| { |
| return count; |
| } |
| |
| public int incrementCount() |
| { |
| return count++; |
| } |
| |
| public void setCount(int count) |
| { |
| this.count = count; |
| } |
| } |
| } |
