Java 类javax.servlet.jsp.el.VariableResolver 实例源码

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);
            }
        }

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);
            }
        }

@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);
}

@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);
}

@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);
}

public Object evaluate(String expression,
                        Class expectedType,
                        VariableResolver vResolver,
                        FunctionMapper fMapper )
            throws ELException {

    ELContextImpl elContext;
    if (vResolver instanceof VariableResolverImpl) {
        elContext = (ELContextImpl) pageContext.getELContext();
    }
    else {
        // The provided variable Resolver is a custom resolver,
        // wrap it with a ELResolver 
        elContext = new ELContextImpl(new ELResolverWrapper(vResolver));
    }

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

@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);
  }
}

@Override
public Expression parseExpression(
        final String expression, final Class expectedType, final FunctionMapper functionMapper)
        throws ELException {

    return new Expression() {
        @Override
        public Object evaluate(VariableResolver variableResolver) throws ELException {
            return doEvaluate(expression, expectedType, functionMapper);
        }
    };
}

@Override
public Object evaluate(
        String expression, Class expectedType, VariableResolver variableResolver, FunctionMapper functionMapper)
        throws ELException {

    if (variableResolver != null) {
        throw new IllegalArgumentException("Custom VariableResolver not supported");
    }
    return doEvaluate(expression, expectedType, functionMapper);
}

@SuppressWarnings("rawtypes")
public Expression parseExpression(final String expression, final Class expectedType,
        final FunctionMapper functionMapper) throws ELException {

    return new Expression() {

        public Object evaluate(VariableResolver variableResolver) throws ELException {
            return doEvaluate(expression, expectedType, functionMapper);
        }
    };
}

@SuppressWarnings("rawtypes")
public Object evaluate(String expression, Class expectedType, VariableResolver variableResolver,
        FunctionMapper functionMapper) throws ELException {

    if (variableResolver != null) {
        throw new IllegalArgumentException("Custom VariableResolver not supported");
    }
    return doEvaluate(expression, expectedType, functionMapper);
}

@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);
}

public Object evaluate(String expression,
                        Class expectedType,
                        VariableResolver vResolver,
                        FunctionMapper fMapper )
            throws ELException {

    ELContextImpl elContext;
    if (vResolver instanceof VariableResolverImpl) {
        elContext = (ELContextImpl) pageContext.getELContext();
    }
    else {
        // The provided variable Resolver is a custom resolver,
        // wrap it with a ELResolver 
        elContext = new ELContextImpl(new ELResolverWrapper(vResolver));
    }

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

@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);
}

@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);
}

@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);
}

@Override
@Deprecated
public VariableResolver getVariableResolver() {
    return this;
}

@Override
@Deprecated
public VariableResolver getVariableResolver() {
    return new VariableResolverImpl(this.getELContext());
}

@Override
public Object evaluate(VariableResolver vResolver) throws ELException {
    ELContext ctx = new ELContextImpl(new ELResolverImpl(vResolver));
    return ve.getValue(ctx);
}

public ELResolverImpl(VariableResolver variableResolver) {
    this.variableResolver = variableResolver;
    this.elResolver = ELContextImpl.getDefaultResolver();
}

public VariableResolver getVariableResolver() {
    return this;
}

public VariableResolver getVariableResolver() {
    return new VariableResolverImpl(this.getELContext());
}

public Object evaluate(String expression, Class expectedType,
        VariableResolver vResolver, FunctionMapper fMapper)
        throws ELException {
    return this.parseExpression(expression, expectedType, fMapper).evaluate(vResolver);
}

public Object evaluate(VariableResolver vResolver) throws ELException {
    ELContext ctx = new ELContextImpl(new ELResolverImpl(vResolver));
    return ve.getValue(ctx);
}

public ELResolverImpl(VariableResolver variableResolver) {
    this.variableResolver = variableResolver;
}

@Override
@Deprecated
public VariableResolver getVariableResolver() {
    return this;
}

@Override
@Deprecated
public VariableResolver getVariableResolver() {
    return new VariableResolverImpl(this.getELContext());
}

@Override
public Object evaluate(VariableResolver vResolver) throws ELException {
    ELContext ctx = new ELContextImpl(new ELResolverImpl(vResolver));
    return ve.getValue(ctx);
}

public ELResolverImpl(VariableResolver variableResolver) {
    this.variableResolver = variableResolver;
    this.elResolver = ELContextImpl.getDefaultResolver();
}

@Override
@Deprecated
public VariableResolver getVariableResolver() {
    return this;
}

@Override
@Deprecated
public VariableResolver getVariableResolver() {
    return new VariableResolverImpl(this.getELContext());
}

@Override
public Object evaluate(VariableResolver vResolver) throws ELException {
    ELContext ctx = new ELContextImpl(new ELResolverImpl(vResolver));
    return ve.getValue(ctx);
}

public ELResolverImpl(VariableResolver variableResolver) {
    this.variableResolver = variableResolver;
    this.elResolver = ELContextImpl.getDefaultResolver();
}

@Override
@Deprecated
public VariableResolver getVariableResolver() {
    return this;
}

@Override
public Object evaluate(VariableResolver vResolver) throws ELException {
    ELContext ctx =
            new ELContextImpl(new ELResolverImpl(vResolver, factory));
    return ve.getValue(ctx);
}

public ELResolverImpl(VariableResolver variableResolver,
        ExpressionFactory factory) {
    this.variableResolver = variableResolver;
    this.elResolver = ELContextImpl.getDefaultResolver(factory);
}

public VariableResolver getVariableResolver() {
    return null;
}

ELResolverWrapper(VariableResolver vResolver) {
    this.vResolver = vResolver;
}

public VariableResolver getVariableResolver() {
return null;
   }

public VariableResolver getVariableResolver() {
    return new VariableResolverImpl(this);
}