public Object getValue(ELContext context, Object base, Object property) { // this resolver only resolves top level variable names to execution variable names. // only handle if this is a top level variable if (base == null) { // we assume a NPE-check for property is not needed // i don't think the next cast can go wrong. can it? String name = (String) property; if (execution != null && NAME_EXECUTION.equals(name)) { context.setPropertyResolved(true); return execution; } if (processInstance != null && NAME_PROCESSINSTANCE.equals(name)) { context.setPropertyResolved(true); return processInstance; } if (task != null && NAME_TASK.equals(name)) { context.setPropertyResolved(true); return task; } } return null; }
public boolean isReadOnly(ELContext context, Object base, Object property) throws ELException { if (base != null) { return false; } if (property == null) { String message = MessageUtils.getExceptionMessageString( MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "property"); throw new PropertyNotFoundException(message); } // return value will be ignored unless context.propertyResolved is // set to true. Integer index = IMPLICIT_OBJECTS.get(property.toString()); if (index == null) { return false; } switch (index) { case FACES_CONTEXT: context.setPropertyResolved(true); return true; case VIEW: context.setPropertyResolved(true); return true; default: return false; } }
@Override public void setValue(ELContext elContext, Object base, Object property, Object value) { if (elContext == null) { throw new NullPointerException(); } if (base != null) { return; } elContext.setPropertyResolved(true); if (property instanceof String) { PageContext pageContext = (PageContext) elContext.getContext(JspContext.class); String attribute = (String) property; if (pageContext.getAttribute(attribute, PageContext.REQUEST_SCOPE) != null) { pageContext.setAttribute(attribute, value, PageContext.REQUEST_SCOPE); } else if (pageContext.getAttribute(attribute, PageContext.SESSION_SCOPE) != null) { pageContext.setAttribute(attribute, value, PageContext.SESSION_SCOPE); } else if (pageContext.getAttribute(attribute, PageContext.APPLICATION_SCOPE) != null) { pageContext.setAttribute(attribute, value, PageContext.APPLICATION_SCOPE); } else { pageContext.setAttribute(attribute, value, PageContext.PAGE_SCOPE); } } }
@Override public Object getValue(ELContext context, Object base, Object property) throws NullPointerException, PropertyNotFoundException, ELException { context.setPropertyResolved(false); int start; Object result = null; if (base == null) { // call implicit and app resolvers int index = 1 /* implicit */ + appResolversSize; for (int i = 0; i < index; i++) { result = resolvers[i].getValue(context, base, property); if (context.isPropertyResolved()) { return result; } } // skip collection-based resolvers (map, resource, list, array, and // bean) start = index + 5; } else { // skip implicit resolver only start = 1; } for (int i = start; i < size; i++) { result = resolvers[i].getValue(context, base, property); if (context.isPropertyResolved()) { return result; } } return null; }
@Override public Object invoke( ELContext context, Object base, Object method, Class<?>[] paramTypes, Object[] params) { String targetMethod = coerceToString(method); if (targetMethod.length() == 0) { throw new ELException(new NoSuchMethodException()); } context.setPropertyResolved(false); Object result = null; // skip implicit and call app resolvers int index = 1 /* implicit */ + appResolversSize; for (int i = 1; i < index; i++) { result = resolvers[i].invoke(context, base, targetMethod, paramTypes, params); if (context.isPropertyResolved()) { return result; } } // skip map, resource, list, and array resolvers index += 4; // call bean and the rest of resolvers for (int i = index; i < size; i++) { result = resolvers[i].invoke(context, base, targetMethod, paramTypes, params); if (context.isPropertyResolved()) { return result; } } return null; }
/** * Set the value of a scoped object for the specified name. * * @param context <code>ELContext</code> for evaluating this value * @param base Base object against which this evaluation occurs (must be null because we are * evaluating a top level variable) * @param property Property name to be accessed * @param value New value to be set */ public void setValue(ELContext context, Object base, Object property, Object value) { if (base != null) { return; } if (property == null) { throw new PropertyNotFoundException("No property specified"); } context.setPropertyResolved(true); String key = property.toString(); Object result = null; FacesContext fcontext = (FacesContext) context.getContext(FacesContext.class); ExternalContext econtext = fcontext.getExternalContext(); if (econtext.getRequestMap().containsKey(property)) { econtext.getRequestMap().put(key, value); } else if (econtext.getSessionMap().containsKey(property)) { econtext.getSessionMap().put(key, value); } else if (econtext.getApplicationMap().containsKey(property)) { econtext.getApplicationMap().put(key, value); } else { econtext.getRequestMap().put(key, value); } }
/** * Return an existing scoped object for the specified name (if any); otherwise, return <code>null * </code>. * * @param context <code>ELContext</code> for evaluating this value * @param base Base object against which this evaluation occurs (must be null because we are * evaluating a top level variable) * @param property Property name to be accessed */ public Object getValue(ELContext context, Object base, Object property) { if (base != null) { return null; } if (property == null) { throw new PropertyNotFoundException("No property specified"); } FacesContext fcontext = (FacesContext) context.getContext(FacesContext.class); ExternalContext econtext = fcontext.getExternalContext(); Object value = null; value = econtext.getRequestMap().get(property); if (value != null) { context.setPropertyResolved(true); return value; } value = econtext.getSessionMap().get(property); if (value != null) { context.setPropertyResolved(true); return value; } value = econtext.getApplicationMap().get(property); if (value != null) { context.setPropertyResolved(true); return value; } return null; }
// taken from TCK facesResourceBundleResolverFeatureDescriptorTest public String getFeatureDescriptorCorrectness() { StringBuilder builder = new StringBuilder(); ELContext elContext = FacesContext.getCurrentInstance().getELContext(); ELResolver resolver = elContext.getELResolver(); boolean fd_Found = false; // Setup golden FeatureDescriptor. FeatureDescriptor controlDesc = new FeatureDescriptor(); controlDesc.setValue("resolvable", Boolean.TRUE); controlDesc.setValue("type", ResourceBundle.class); controlDesc.setName("resourceBundle03"); controlDesc.setDisplayName("simple"); controlDesc.setExpert(false); controlDesc.setHidden(false); controlDesc.setPreferred(true); controlDesc.setShortDescription(""); builder.append("<h1>getFeatureDescriptors output</h1>\n"); for (Iterator i = resolver.getFeatureDescriptors(elContext, null); i.hasNext(); ) { FeatureDescriptor test = (FeatureDescriptor) i.next(); builder .append("<p>Name: ") .append(test.getName()) .append(" displayName: ") .append(test.getDisplayName()) .append("</p>\n"); } return builder.toString(); }
/* * (non-Javadoc) * * @see javax.el.ValueExpression#setValue(javax.el.ELContext, * java.lang.Object) */ public void setValue(ELContext context, Object value) { Object base = this.orig.getValue(context); if (base != null) { context.setPropertyResolved(false); context.getELResolver().setValue(context, base, key, value); } }
/* * (non-Javadoc) * * @see javax.el.ValueExpression#isReadOnly(javax.el.ELContext) */ public boolean isReadOnly(ELContext context) { Object base = this.orig.getValue(context); if (base != null) { context.setPropertyResolved(false); return context.getELResolver().isReadOnly(context, base, key); } return true; }
/* * (non-Javadoc) * * @see javax.el.ValueExpression#getType(javax.el.ELContext) */ public Class getType(ELContext context) { Object base = this.orig.getValue(context); if (base != null) { context.setPropertyResolved(false); return context.getELResolver().getType(context, base, key); } return null; }
// taken from TCK facesResourceBundleResolverGetTypeTest public String getResourceBundleType() { FacesContext context = FacesContext.getCurrentInstance(); ELContext elContext = context.getELContext(); ELResolver elResolver = elContext.getELResolver(); Class type = elResolver.getType(elContext, null, "resourceBundle03"); return type.toString(); }
/** * @param result * @param element * @param dataList */ public void processRepeat( Node result, Element element, Iterable<?> dataList, Runnable onEachLoop) { if (dataList == null) { return; } // Compute list size int size = Iterables.size(dataList); if (size > 0) { // Save the initial EL state Map<String, ? extends Object> oldContext = templateContext.getContext(); Object oldCur = templateContext.getCur(); ValueExpression oldVarExpression = null; // Set the new Context variable. Copy the old context to preserve // any existing "index" variable Map<String, Object> loopData = Maps.newHashMap(oldContext); loopData.put(PROPERTY_COUNT, size); templateContext.setContext(loopData); // TODO: This means that any loop with @var doesn't make the loop // variable available in the default expression context. // Update the specification to make this explicit. Attr varAttr = element.getAttributeNode(ATTRIBUTE_VAR); if (varAttr == null) { oldCur = templateContext.getCur(); } else { oldVarExpression = elContext.getVariableMapper().resolveVariable(varAttr.getValue()); } Attr indexVarAttr = element.getAttributeNode(ATTRIBUTE_INDEX); String indexVar = indexVarAttr == null ? PROPERTY_INDEX : indexVarAttr.getValue(); int index = 0; for (Object data : dataList) { loopData.put(indexVar, index++); // Set up context for rendering inner node templateContext.setCur(data); if (varAttr != null) { ValueExpression varExpression = expressions.constant(data, Object.class); elContext.getVariableMapper().setVariable(varAttr.getValue(), varExpression); } onEachLoop.run(); } // Restore EL state if (varAttr == null) { templateContext.setCur(oldCur); } else { elContext.getVariableMapper().setVariable(varAttr.getValue(), oldVarExpression); } templateContext.setContext(oldContext); } }
@Override @SuppressWarnings("deprecation") public Object getValue(ELContext context, Object base, Object property) throws ELException { // Don't call into the chain unless it's been decorated. if (legacyVR instanceof ChainAwareVariableResolver) { return null; } if (base != null) { return null; } if (base == null && property == null) { String message = MessageUtils.getExceptionMessageString( MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "base and property"); // ????? throw new PropertyNotFoundException(message); } context.setPropertyResolved(true); Object result = null; FacesContext facesContext = (FacesContext) context.getContext(FacesContext.class); String propString = property.toString(); Map<String, Object> stateMap = RequestStateManager.getStateMap(facesContext); try { // If we are already in the midst of an expression evaluation // that touched this resolver... //noinspection unchecked List<String> varNames = (List<String>) stateMap.get(RequestStateManager.REENTRANT_GUARD); if (varNames != null && !varNames.isEmpty() && varNames.contains(propString)) { // take no action and return. context.setPropertyResolved(false); return null; } // Make sure subsequent calls don't take action. if (varNames == null) { varNames = new ArrayList<>(); stateMap.put(RequestStateManager.REENTRANT_GUARD, varNames); } varNames.add(propString); result = legacyVR.resolveVariable(facesContext, propString); } catch (EvaluationException ex) { context.setPropertyResolved(false); throw new ELException(ex); } finally { // Make sure to remove the guard after the call returns //noinspection unchecked List<String> varNames = (List<String>) stateMap.get(RequestStateManager.REENTRANT_GUARD); if (varNames != null && !varNames.isEmpty()) { varNames.remove(propString); } // Make sure that the ELContext "resolved" indicator is set // in accordance wth the result of the resolution. context.setPropertyResolved(result != null); } return result; }
public void contextDestroyed(ServletContextEvent sce) { ServletContext context = sce.getServletContext(); InitFacesContext initContext = null; try { initContext = new InitFacesContext(context); if (webAppListener != null) { webAppListener.contextDestroyed(sce); webAppListener = null; } if (webResourcePool != null) { webResourcePool.shutdownNow(); } if (!ConfigManager.getInstance().hasBeenInitialized(context)) { return; } GroovyHelper helper = GroovyHelper.getCurrentInstance(context); if (helper != null) { helper.setClassLoader(); } if (LOGGER.isLoggable(Level.FINE)) { LOGGER.log( Level.FINE, "ConfigureListener.contextDestroyed({0})", context.getServletContextName()); } ELContext elctx = new ELContextImpl(initContext.getApplication().getELResolver()); elctx.putContext(FacesContext.class, initContext); initContext.setELContext(elctx); Application app = initContext.getApplication(); app.publishEvent(initContext, PreDestroyApplicationEvent.class, Application.class, app); Util.setNonFacesContextApplicationMap(null); } catch (Exception e) { if (LOGGER.isLoggable(Level.SEVERE)) { LOGGER.log( Level.SEVERE, "Unexpected exception when attempting to tear down the Mojarra runtime", e); } } finally { ApplicationAssociate.clearInstance(initContext.getExternalContext()); ApplicationAssociate.setCurrentInstance(null); com.sun.faces.application.ApplicationImpl.clearInstance(initContext.getExternalContext()); com.sun.faces.application.InjectionApplicationFactory.clearInstance( initContext.getExternalContext()); // Release the initialization mark on this web application ConfigManager.getInstance().destory(context); if (initContext != null) { initContext.release(); } ReflectionUtils.clearCache(Thread.currentThread().getContextClassLoader()); WebConfiguration.clear(context); } }
private Object evaluateProperty(Object base, String property) { ELContext elCtx = FacesContext.getCurrentInstance().getELContext(); // simple property -> resolve value directly if (!property.contains(".")) { return elCtx.getELResolver().getValue(elCtx, base, property); } int index = property.indexOf('.'); Object newBase = elCtx.getELResolver().getValue(elCtx, base, property.substring(0, index)); return evaluateProperty(newBase, property.substring(index + 1)); }
@SuppressWarnings("unchecked") public <T> T getExpressionValue(FacesContext context, String exp, Class<T> returnType) { ELContext elContext = context.getELContext(); boolean propertyResolved = elContext.isPropertyResolved(); try { ValueExpression valueExpression = createElExpression(elContext, exp, returnType); return (T) valueExpression.getValue(elContext); } finally { elContext.setPropertyResolved(propertyResolved); } }
protected <T> T findBean(FacesContext context, Class<T> type, String beanName) { ELContext elContext = context.getELContext(); boolean propertyResolved = elContext.isPropertyResolved(); try { return context .getApplication() .evaluateExpressionGet( context, "#" + "{" + beanName + "}", type); // Warning EL string is not closed } finally { elContext.setPropertyResolved(propertyResolved); } }
public ExpressionBuilder(String expression, ELContext ctx) throws ELException { this.expression = expression; FunctionMapper ctxFn = ctx.getFunctionMapper(); VariableMapper ctxVar = ctx.getVariableMapper(); if (ctxFn != null) { this.fnMapper = new FunctionMapperFactory(ctxFn); } if (ctxVar != null) { this.varMapper = new VariableMapperFactory(ctxVar); } }
protected FacesContext getFacesContext( PortletRequest portletRequest, PortletResponse portletResponse, Lifecycle lifecycle) { FacesContext newFacesContext = getFacesContextFactory() .getFacesContext(portletContext, portletRequest, portletResponse, lifecycle); // TCK TestPage203 (JSF_ELTest) ensure that the #{facesContext} implicit object is set to the // current instance. ELContext elContext = newFacesContext.getELContext(); elContext.putContext(FacesContext.class, newFacesContext); return newFacesContext; }
/** 返回上下文中唯一的文档对象. */ public static Document getContextDocument(ELContext elctx) { Document doc = (Document) elctx.getContext(Document.class); if (doc == null) { try { DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); DocumentBuilder db = dbf.newDocumentBuilder(); doc = db.newDocument(); elctx.putContext(Document.class, doc); } catch (ParserConfigurationException ex) { throw new ELException(ex); } } return doc; }
@Override public Class<?> getType(ELContext context, Object base, Object property) { Class<?> type = null; if (base instanceof DocumentModel) { try { type = super.getType(context, base, property); } catch (PropertyNotFoundException e) { type = DocumentPropertyContext.class; context.setPropertyResolved(true); } } else if (base instanceof DocumentPropertyContext || base instanceof Property) { type = Object.class; if (base instanceof DocumentPropertyContext) { DocumentPropertyContext ctx = (DocumentPropertyContext) base; try { Property docProperty = getDocumentProperty(ctx, property); if (docProperty.isContainer()) { Property subProperty = getDocumentProperty(docProperty, property); if (subProperty.isList()) { type = List.class; } } else if (docProperty instanceof ArrayProperty) { type = List.class; } } catch (PropertyException pe) { // avoid errors, return Object log.warn(pe.toString()); } } else if (base instanceof Property) { try { Property docProperty = (Property) base; Property subProperty = getDocumentProperty(docProperty, property); if (subProperty.isList()) { type = List.class; } } catch (PropertyException pe) { try { // try property getters to resolve // doc.schema.field.type for instance type = super.getType(context, base, property); } catch (PropertyNotFoundException e) { // avoid errors, log original error and return Object log.warn(pe.toString()); } } } context.setPropertyResolved(true); } return type; }
/** @see javax.el.ELResolver#getValue(ELContext, Object, Object) */ @Override public Object getValue(ELContext context, Object base, Object property) { if (property != null) { String propertyString = property.toString(); Namespace namespace = null; if (base == null) { if (manager.getRootNamespace().contains(propertyString)) { context.setPropertyResolved(true); return manager.getRootNamespace().get(propertyString); } } else if (base instanceof Namespace) { namespace = (Namespace) base; // We're definitely the responsible party context.setPropertyResolved(true); if (namespace.contains(propertyString)) { // There is a child namespace return namespace.get(propertyString); } } else { // let the standard EL resolver chain handle the property return null; } final String name; if (namespace != null) { // Try looking in the manager for a bean name = namespace.qualifyName(propertyString); } else { name = propertyString; } Object value = null; try { Bean<?> bean = manager.resolve(manager.getBeans(name)); CreationalContext<?> creationalContext = manager.createCreationalContext(bean); if (bean != null) { value = manager.getReference(bean, creationalContext); } creationalContext.release(); } catch (Exception e) { throw new RuntimeException( "Error resolving property " + propertyString + " against base " + base, e); } if (value != null) { context.setPropertyResolved(true); return value; } } return null; }
@Override public boolean isReadOnly(ELContext context, Object base, Object property) { boolean readOnly = false; try { readOnly = super.isReadOnly(context, base, property); } catch (PropertyNotFoundException e) { if (base instanceof DocumentModel || base instanceof DocumentPropertyContext) { readOnly = false; context.setPropertyResolved(true); } else if (base instanceof Property) { readOnly = ((Property) base).isReadOnly(); context.setPropertyResolved(true); } } return readOnly; }
public Class<?> getType(ELContext context, Object base, Object property) throws ELException { if (base != null) { return null; } if (property == null) { String message = MessageUtils.getExceptionMessageString( MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "property"); throw new PropertyNotFoundException(message); } Integer index = IMPLICIT_OBJECTS.get(property.toString()); if (index == null) { return null; } switch (index) { case FACES_CONTEXT: case VIEW: context.setPropertyResolved(true); return null; default: return null; } }
// Capture the base and property rather than write the value @Override public void setValue(ELContext context, Object base, Object property, Object value) { if (base != null && property != null) { context.setPropertyResolved(true); valueReference = new ValueReference(base, property.toString()); } }
/** * Evaluate the expr as an object. * * @param env the page context */ @Override public Object getValue(ELContext env) throws ELException { if (!(env instanceof ServletELContext)) return env.getELResolver().getValue(env, null, "session"); env.setPropertyResolved(true); ServletELContext servletEnv = (ServletELContext) env; HttpServletRequest req = servletEnv.getRequest(); HttpSession session = req.getSession(false); if (session != null) return session.getAttribute(_field); else return null; }
@Test public void testInvoke() { TesterBeanB beanB = new TesterBeanB(); beanB.setName("B"); context .getVariableMapper() .setVariable("beanB", factory.createValueExpression(beanB, TesterBeanB.class)); MethodExpression me1 = factory.createMethodExpression( context, "${beanB.getName}", String.class, new Class<?>[] {}); MethodExpression me2 = factory.createMethodExpression( context, "${beanB.sayHello('JUnit')}", String.class, new Class<?>[] {String.class}); MethodExpression me3 = factory.createMethodExpression( context, "${beanB.sayHello}", String.class, new Class<?>[] {String.class}); assertEquals("B", me1.invoke(context, null)); assertEquals("Hello JUnit from B", me2.invoke(context, null)); assertEquals("Hello JUnit from B", me2.invoke(context, new Object[] {"JUnit2"})); assertEquals("Hello JUnit2 from B", me3.invoke(context, new Object[] {"JUnit2"})); assertEquals("Hello JUnit from B", me2.invoke(context, new Object[] {null})); assertEquals("Hello from B", me3.invoke(context, new Object[] {null})); }
/** * Return <code>true</code> if the specified property is read only. * * @param context <code>ELContext</code> for evaluating this value * @param base Base object against which this evaluation occurs (must be null because we are * evaluating a top level variable) * @param property Property name to be accessed */ public boolean isReadOnly(ELContext context, Object base, Object property) { if (base == null) { context.setPropertyResolved(true); return false; } return false; }
/* * (non-Javadoc) * * @see javax.el.ValueExpression#getValue(javax.el.ELContext) */ public Object getValue(ELContext context) { Object base = this.orig.getValue(context); if (base != null) { context.setPropertyResolved(true); return new Entry((Map) base, key); } return null; }