Java ELException类代码示例

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
public Expression parseExpression(String expression,
                                  Class expectedType,
                                  FunctionMapper fMapper )
        throws ELException {

    ExpressionFactory fac = ExpressionFactory.newInstance();
    javax.el.ValueExpression expr;
    ELContextImpl elContext = new ELContextImpl(null);
    javax.el.FunctionMapper fm = new FunctionMapperWrapper(fMapper);
    elContext.setFunctionMapper(fm);
    try {
        expr = fac.createValueExpression(
                       elContext,
                       expression, expectedType);
    } catch (javax.el.ELException ex) {
        throw new ELException(ex);
    }
    return new ExpressionImpl(expr, pageContext);
}
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
@Override
public Expression parseExpression(String expression,
        @SuppressWarnings("rawtypes") // API does not use generics
        Class expectedType,
        FunctionMapper fMapper) throws ELException {
    try {
        ELContextImpl ctx =
            new ELContextImpl(ELContextImpl.getDefaultResolver());
        if (fMapper != null) {
            ctx.setFunctionMapper(new FunctionMapperImpl(fMapper));
        }
        ValueExpression ve = this.factory.createValueExpression(ctx, expression, expectedType);
        return new ExpressionImpl(ve);
    } catch (javax.el.ELException e) {
        throw new ELParseException(e.getMessage());
    }
}
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
@Override
public Expression parseExpression(String expression, @SuppressWarnings("rawtypes") // API
																					// does
																					// not
																					// use
																					// generics
Class expectedType, FunctionMapper fMapper) throws ELException {
	try {
		ELContextImpl ctx = new ELContextImpl(ELContextImpl.getDefaultResolver());
		if (fMapper != null) {
			ctx.setFunctionMapper(new FunctionMapperImpl(fMapper));
		}
		ValueExpression ve = this.factory.createValueExpression(ctx, expression, expectedType);
		return new ExpressionImpl(ve);
	} catch (javax.el.ELException e) {
		throw new ELParseException(e.getMessage());
	}
}
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
public Object evaluate(VariableResolver vResolver) throws ELException {

            ELContext elContext;
            if (vResolver instanceof VariableResolverImpl) {
                elContext = pageContext.getELContext();
            }
            else {
                // The provided variable Resolver is a custom resolver,
                // wrap it with a ELResolver 
                elContext = new ELContextImpl(new ELResolverWrapper(vResolver));
            }
            try {
                return valueExpr.getValue(elContext);
            } catch (javax.el.ELException ex) {
                throw new ELException(ex);
            }
        }
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
@Override
public Expression parseExpression(String expression,
        @SuppressWarnings("rawtypes") // API does not use generics
        Class expectedType,
        FunctionMapper fMapper) throws ELException {
    try {
        ELContextImpl ctx =
            new ELContextImpl(ELResolverImpl.getDefaultResolver());
        if (fMapper != null) {
            ctx.setFunctionMapper(new FunctionMapperImpl(fMapper));
        }
        ValueExpression ve = this.factory.createValueExpression(ctx, expression, expectedType);
        return new ExpressionImpl(ve);
    } catch (javax.el.ELException e) {
        throw new ELParseException(e.getMessage());
    }
}
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
/**
 * VariableResolver interface
 */
@Override
@Deprecated
public Object resolveVariable(String pName) throws ELException {
    ELContext ctx = this.getELContext();
    return ctx.getELResolver().getValue(ctx, null, pName);
}
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
@Override
public Object evaluate(String expression,
        @SuppressWarnings("rawtypes") // API does not use generics
        Class expectedType,
        VariableResolver vResolver, FunctionMapper fMapper)
        throws ELException {
    return this.parseExpression(expression, expectedType, fMapper).evaluate(vResolver);
}
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
public Expression parseExpression(String expression, Class expectedType,
        FunctionMapper fMapper) throws ELException {
    try {
        ELContextImpl ctx =
            new ELContextImpl(ELResolverImpl.getDefaultResolver());
        if (fMapper != null) {
            ctx.setFunctionMapper(new FunctionMapperImpl(fMapper));
        }
        ValueExpression ve = this.factory.createValueExpression(ctx, expression, expectedType);
        return new ExpressionImpl(ve);
    } catch (javax.el.ELException e) {
        throw new ELParseException(e.getMessage());
    }
}
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
/**
 * VariableResolver interface
 */
@Override
@Deprecated
public Object resolveVariable(String pName) throws ELException {
	ELContext ctx = this.getELContext();
	return ctx.getELResolver().getValue(ctx, null, pName);
}
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
@Override
public Object evaluate(String expression, @SuppressWarnings("rawtypes") // API
																		// does
																		// not
																		// use
																		// generics
Class expectedType, VariableResolver vResolver, FunctionMapper fMapper) throws ELException {
	return this.parseExpression(expression, expectedType, fMapper).evaluate(vResolver);
}
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
/**
 * Recognizes a couple of special variables, and if the property requested
 * isn't one of them, just looks up a property on the action bean.
 *
 * @param property the name of the variable/property being looked for
 * @return the property value or null
 * @throws javax.servlet.jsp.el.ELException
 */
public Object resolveVariable(String property) throws ELException {
    if (isSelfKeyword(bean, property)) {
        return this.currentValue;
    }
    else if (StripesConstants.REQ_ATTR_ACTION_BEAN.equals(property)) {
        return this.bean;
    }
    else {
        try { return BeanUtil.getPropertyValue(property, bean); }
        catch (Exception e) { return null; }
    }
}
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
public Object getValue(ELContext context,
                       Object base,
                       Object property)
        throws javax.el.ELException {
    if (base == null) {
        context.setPropertyResolved(true);
        try {
            return vResolver.resolveVariable(property.toString());
        } catch (ELException ex) {
            throw new javax.el.ELException(ex);
        }
    }
    return null;
}
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
private Throwable getRootCause(Throwable ex) {
    final Throwable rx;
    if (ex instanceof ServletException) {
        rx = ((ServletException) ex).getRootCause();
    } else if (ex instanceof ELException) {
        rx = ((ELException) ex).getRootCause();
    } else if (ex != null) {
        rx = ex.getCause();
    } else {
        rx = null;
    }
    return rx == null ? ex : getRootCause(rx);
}
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
public static void parseEL(String el) throws ELEvalException {
  try {
    EVALUATOR.parseExpressionString(el);
  } catch (ELException e) {
    LOG.debug("Error parsering EL '{}': {}", el, e.toString(), e);
    throw new ELEvalException(CommonError.CMN_0105, el, e.toString(), e);
  }
}
 

import javax.servlet.jsp.el.ELException; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public <T> T evaluate (final ELVars vars, String expression, Class<T> returnType) throws ELEvalException {
  VariableResolver variableResolver = new VariableResolver() {

    @Override
    public Object resolveVariable(String name) throws ELException {
      Object value = constants.get(name);
      if (!vars.hasVariable(name)) {
        if (value == null && !constants.containsKey(name)) {
          throw new ELException(Utils.format("Constants/Variable '{}' cannot be resolved", name));
        }
      } else {
        value = vars.getVariable(name);
      }
      return value;
    }
  };
  try {
    return (T) EVALUATOR.evaluate(expression, returnType, variableResolver, functionMapper);
  } catch (ELException e) {
    // Apache evaluator is not using the getCause exception chaining that is available in Java but rather a custom
    // chaining mechanism. This doesn't work well for us as we're effectively swallowing the cause that is not
    // available in log, ...
    Throwable t = e;
    if(e.getRootCause() != null) {
      t = e.getRootCause();
      if(e.getCause() == null) {
        e.initCause(t);
      }
    }
    LOG.debug("Error valuating EL '{}': {}", expression, e.toString(), e);
    throw new ELEvalException(CommonError.CMN_0104, expression, t.toString(), e);
  }
}