Java ValueExpression.getValue方法代码示例

import javax.el.ValueExpression; //导入方法依赖的package包/类
/**
 * Test using list directly as variable.
 */
@Test
public void testBug51544Direct() throws Exception {
    ExpressionFactory factory = ExpressionFactory.newInstance();
    ELContext context = new ELContextImpl();

    List<?> list = Collections.emptyList();

    ValueExpression var =
        factory.createValueExpression(list, List.class);
    context.getVariableMapper().setVariable("list", var);

    ValueExpression ve = factory.createValueExpression(
            context, "${list.size()}", Integer.class);

    Integer result = (Integer) ve.getValue(context);
    assertEquals(Integer.valueOf(0), result);
}
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
@Override
public Object getValue(EvaluationContext ctx) throws ELException {
    VariableMapper varMapper = ctx.getVariableMapper();
    if (varMapper != null) {
        ValueExpression expr = varMapper.resolveVariable(this.image);
        if (expr != null) {
            return expr.getValue(ctx.getELContext());
        }
    }
    ctx.setPropertyResolved(false);
    Object result = ctx.getELResolver().getValue(ctx, null, this.image);
    if (!ctx.isPropertyResolved()) {
        throw new PropertyNotFoundException(MessageFactory.get(
                "error.resolver.unhandled.null", this.image));
    }
    return result;
}
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
private void doTestBug56179(int parenthesesCount, String innerExpr) {
    ExpressionFactory factory = ExpressionFactory.newInstance();
    ELContext context = new ELContextImpl();

    ValueExpression var =
        factory.createValueExpression(Boolean.TRUE, Boolean.class);
    context.getVariableMapper().setVariable("test", var);

    StringBuilder expr = new StringBuilder();
    expr.append("${");
    for (int i = 0; i < parenthesesCount; i++) {
        expr.append("(");
    }
    expr.append(innerExpr);
    for (int i = 0; i < parenthesesCount; i++) {
        expr.append(")");
    }
    expr.append("}");
    ValueExpression ve = factory.createValueExpression(
            context, expr.toString(), String.class);

    String result = (String) ve.getValue(context);
    assertEquals("true", result);
}
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
@Test
public void testBug53792b() {
    MethodExpression me = factory.createMethodExpression(context,
            "${beanA.setBean(beanB)}", null ,
            new Class<?>[] { TesterBeanB.class });
    me.invoke(context, null);
    me = factory.createMethodExpression(context,
            "${beanB.setName('" + BUG53792 + "')}", null ,
            new Class<?>[] { TesterBeanB.class });
    me.invoke(context, null);

    ValueExpression ve = factory.createValueExpression(context,
            "#{beanA.getBean().name.length()}", java.lang.Integer.class);
    Integer actual = (Integer) ve.getValue(context);
    assertEquals(Integer.valueOf(BUG53792.length()), actual);
}
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
/**
 * Test returning an empty list as a bean property.
 */
@Test
public void testBug51544Bean() throws Exception {
    ExpressionFactory factory = ExpressionFactory.newInstance();
    ELContext context = new ELContextImpl();

    TesterBeanA beanA = new TesterBeanA();
    beanA.setValList(Collections.emptyList());

    ValueExpression var =
        factory.createValueExpression(beanA, TesterBeanA.class);
    context.getVariableMapper().setVariable("beanA", var);

    ValueExpression ve = factory.createValueExpression(
            context, "${beanA.valList.size()}", Integer.class);

    Integer result = (Integer) ve.getValue(context);
    assertEquals(Integer.valueOf(0), result);
}
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
@Override
public Object getValue(EvaluationContext ctx) throws ELException {
	VariableMapper varMapper = ctx.getVariableMapper();
	if (varMapper != null) {
		ValueExpression expr = varMapper.resolveVariable(this.image);
		if (expr != null) {
			return expr.getValue(ctx.getELContext());
		}
	}
	ctx.setPropertyResolved(false);
	Object result = ctx.getELResolver().getValue(ctx, null, this.image);
	if (!ctx.isPropertyResolved()) {
		throw new PropertyNotFoundException(MessageFactory.get("error.resolver.unhandled.null", this.image));
	}
	return result;
}
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
private final MethodExpression getMethodExpression(EvaluationContext ctx)
        throws ELException {
    Object obj = null;

    // case A: ValueExpression exists, getValue which must
    // be a MethodExpression
    VariableMapper varMapper = ctx.getVariableMapper();
    ValueExpression ve = null;
    if (varMapper != null) {
        ve = varMapper.resolveVariable(this.image);
        if (ve != null) {
            obj = ve.getValue(ctx);
        }
    }

    // case B: evaluate the identity against the ELResolver, again, must be
    // a MethodExpression to be able to invoke
    if (ve == null) {
        ctx.setPropertyResolved(false);
        obj = ctx.getELResolver().getValue(ctx, null, this.image);
    }

    // finally provide helpful hints
    if (obj instanceof MethodExpression) {
        return (MethodExpression) obj;
    } else if (obj == null) {
        throw new MethodNotFoundException("Identity '" + this.image
                + "' was null and was unable to invoke");
    } else {
        throw new ELException(
                "Identity '"
                        + this.image
                        + "' does not reference a MethodExpression instance, returned type: "
                        + obj.getClass().getName());
    }
}
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
public void safeEL() {
    FacesContext context = FacesContext.getCurrentInstance();
    ExpressionFactory expressionFactory = context.getApplication().getExpressionFactory();
    ELContext elContext = context.getELContext();
    ValueExpression vex = expressionFactory.createValueExpression(elContext, "1+1", String.class);
    String result = (String) vex.getValue(elContext);
    System.out.println(result);
}
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
@Test
public void testBug50790a() throws Exception {
    ValueExpression ve = factory.createValueExpression(context,
            "#{beanAA.name.contains(beanA.name)}", java.lang.Boolean.class);
    Boolean actual = (Boolean) ve.getValue(context);
    assertEquals(Boolean.TRUE, actual);
}
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
@Test
public void testBug50790b() throws Exception {
    ValueExpression ve = factory.createValueExpression(context,
            "#{beanA.name.contains(beanAA.name)}", java.lang.Boolean.class);
    Boolean actual = (Boolean) ve.getValue(context);
    assertEquals(Boolean.FALSE, actual);
}
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
private String evalAttr(String expression, char quote) {

        ELContextImpl ctx = new ELContextImpl();
        ctx.setFunctionMapper(new FMapper());
        ExpressionFactoryImpl exprFactory = new ExpressionFactoryImpl();
        ValueExpression ve = exprFactory.createValueExpression(ctx,
                AttributeParser.getUnquoted(expression, quote, false, false,
                        false, false),
                String.class);
        return (String) ve.getValue(ctx);
    }
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
public void unsafeEL(String expression) {
    FacesContext context = FacesContext.getCurrentInstance();
    ExpressionFactory expressionFactory = context.getApplication().getExpressionFactory();
    ELContext elContext = context.getELContext();
    ValueExpression vex = expressionFactory.createValueExpression(elContext, expression, String.class);
    String result = (String) vex.getValue(elContext);
    System.out.println(result);
}
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
@Test
public void testBug49345() {
    ExpressionFactory factory = ExpressionFactory.newInstance();
    ELContext context = new ELContextImpl();

    TesterBeanA beanA = new TesterBeanA();
    TesterBeanB beanB = new TesterBeanB();
    beanB.setName("Tomcat");
    beanA.setBean(beanB);

    ValueExpression var =
        factory.createValueExpression(beanA, TesterBeanA.class);
    context.getVariableMapper().setVariable("beanA", var);

    ValueExpression ve = factory.createValueExpression(
            context, "${beanA.bean.name}", String.class);

    // First check the basics work
    String result = (String) ve.getValue(context);
    assertEquals("Tomcat", result);

    // Now check the value reference
    ValueReference vr = ve.getValueReference(context);
    assertNotNull(vr);

    assertEquals(beanB, vr.getBase());
    assertEquals("name", vr.getProperty());
}
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
private String evaluateExpression(String expression) {
    ELContextImpl ctx = new ELContextImpl();
    ctx.setFunctionMapper(new FMapper());
    ExpressionFactoryImpl exprFactory = new ExpressionFactoryImpl();
    ValueExpression ve = exprFactory.createValueExpression(ctx, expression,
            String.class);
    return (String) ve.getValue(ctx);
}
 

import javax.el.ValueExpression; //导入方法依赖的package包/类
/**
 * Set a property of type int[].  If the value
 * is an EL expression, it will be stored as a ValueExpression.
 * Otherwise, it will parsed as a whitespace-separated series
 * of ints.
 * Null values are ignored.
 */
protected void setIntArrayProperty(
  FacesBean   bean,
  PropertyKey key,
  ValueExpression expression)
{
  if (expression == null)
    return;

  if (expression.isLiteralText())
  {
    Object value = expression.getValue(FacesContext.getCurrentInstance().getELContext());
    if (value != null)
    {
      String[] strings = TagUtils.parseNameTokens(value);
      final int[] ints;
      if (strings != null)
      {
        try
        {
          ints = new int[strings.length];
          for(int i=0; i<strings.length; i++)
          {
            int j = Integer.parseInt(strings[i]);
            ints[i] = j;
          }
        }
        catch (NumberFormatException e)
        {
          _LOG.severe("CANNOT_CONVERT_INTO_INT_ARRAY",value);
          _LOG.severe(e);
          return;
        }
      }
    }
  }
  else
  {
    bean.setValueExpression(key, expression);
  }
}