下面列出了javax.servlet.jsp.el.VariableResolver#javax.el.ELContext 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@Override
public Object getValue(ELContext context, Object base, Object property)
throws NullPointerException, PropertyNotFoundException, ELException {
if (context == null) {
throw new NullPointerException();
}
if (base == null) {
context.setPropertyResolved(true);
if (property != null) {
try {
return this.variableResolver.resolveVariable(property
.toString());
} catch (javax.servlet.jsp.el.ELException e) {
throw new ELException(e.getMessage(), e.getCause());
}
}
}
if (!context.isPropertyResolved()) {
return elResolver.getValue(context, base, property);
}
return null;
}
/**
* Coerce an object to a string.
* @param ctx the context in which this conversion is taking place
* @param obj the object to convert
* @return the String value of the object
*/
public static final String coerceToString(final ELContext ctx, final Object obj) {
if (ctx != null) {
boolean originalIsPropertyResolved = ctx.isPropertyResolved();
try {
Object result = ctx.getELResolver().convertToType(ctx, obj, String.class);
if (ctx.isPropertyResolved()) {
return (String) result;
}
} finally {
ctx.setPropertyResolved(originalIsPropertyResolved);
}
}
if (obj == null) {
return "";
} else if (obj instanceof String) {
return (String) obj;
} else if (obj instanceof Enum<?>) {
return ((Enum<?>) obj).name();
} else {
return obj.toString();
}
}
@Override
public void setValue(ELContext context, Object base, Object property,
Object value) throws NullPointerException,
PropertyNotFoundException, PropertyNotWritableException,
ELException {
if (context == null) {
throw new NullPointerException();
}
if (base == null) {
context.setPropertyResolved(true);
throw new PropertyNotWritableException(
"Legacy VariableResolver wrapped, not writable");
}
if (!context.isPropertyResolved()) {
elResolver.setValue(context, base, property, value);
}
}
private ELContext createELContext(final ELResolver resolver, final FunctionMapper functionMapper, final VariableMapper variableMapper) {
return new ELContext() {
@Override
public ELResolver getELResolver() {
return resolver;
}
@Override
public FunctionMapper getFunctionMapper() {
return functionMapper;
}
@Override
public VariableMapper getVariableMapper() {
return variableMapper;
}
};
}
@Test
public void testBug51177ObjectMap() {
ExpressionFactory factory = ExpressionFactory.newInstance();
ELContext context = new ELContextImpl();
Object o1 = "String value";
Object o2 = Integer.valueOf(32);
Map<Object,Object> map = new HashMap<Object,Object>();
map.put("key1", o1);
map.put("key2", o2);
ValueExpression var =
factory.createValueExpression(map, Map.class);
context.getVariableMapper().setVariable("map", var);
ValueExpression ve1 = factory.createValueExpression(
context, "${map.key1}", Object.class);
ve1.setValue(context, o2);
assertEquals(o2, ve1.getValue(context));
ValueExpression ve2 = factory.createValueExpression(
context, "${map.key2}", Object.class);
ve2.setValue(context, o1);
assertEquals(o1, ve2.getValue(context));
}
@Override
public Object getValue(ELContext context, Object base, Object property)
throws NullPointerException, PropertyNotFoundException, ELException {
if (context == null) {
throw new NullPointerException();
}
if (base == null) {
context.setPropertyResolved(true);
if (property != null) {
try {
return this.variableResolver.resolveVariable(property
.toString());
} catch (javax.servlet.jsp.el.ELException e) {
throw new ELException(e.getMessage(), e.getCause());
}
}
}
if (!context.isPropertyResolved()) {
return elResolver.getValue(context, base, property);
}
return null;
}
@Override
public void setValue(ELContext context, Object base, Object property,
Object value) throws NullPointerException,
PropertyNotFoundException, PropertyNotWritableException,
ELException {
if (context == null) {
throw new NullPointerException();
}
if (base == null) {
context.setPropertyResolved(true);
throw new PropertyNotWritableException(
"Legacy VariableResolver wrapped, not writable");
}
if (!context.isPropertyResolved()) {
elResolver.setValue(context, base, property, value);
}
}
private int intVal(
AstNode node,
int defVal,
int baseLength,
Bindings bindings,
ELContext context
) {
if (node == null) {
return defVal;
}
Object val = node.eval(bindings, context);
if (val == null) {
return defVal;
}
if (!(val instanceof Number)) {
throw new ELException("Range start/end is not a number");
}
int result = ((Number) val).intValue();
return result >= 0 ? result : baseLength + result;
}
@Test
public void testJavaKeyWordSuffix() {
ExpressionFactory factory = ExpressionFactory.newInstance();
ELContext context = new ELContextImpl(factory);
TesterBeanA beanA = new TesterBeanA();
beanA.setInt("five");
ValueExpression var =
factory.createValueExpression(beanA, TesterBeanA.class);
context.getVariableMapper().setVariable("beanA", var);
// Should fail
Exception e = null;
try {
factory.createValueExpression(context, "${beanA.int}",
String.class);
} catch (ELException ele) {
e = ele;
}
Assert.assertNotNull(e);
}
@Override
public void setValue(ELContext context, Object base, Object property,
Object value) throws NullPointerException,
PropertyNotFoundException, PropertyNotWritableException,
ELException {
if (context == null) {
throw new NullPointerException();
}
if (base == null && property != null) {
int idx = Arrays.binarySearch(SCOPE_NAMES, property.toString());
if (idx >= 0) {
context.setPropertyResolved(true);
throw new PropertyNotWritableException();
}
}
}
private void doTestBug56179(int parenthesesCount, String innerExpr) {
ExpressionFactory factory = ExpressionFactory.newInstance();
ELContext context = new ELContextImpl(factory);
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);
Assert.assertEquals("true", result);
}
@Test
public void testGetValueReference() {
ExpressionFactory factory = ExpressionFactory.newInstance();
ELContext context = new ELContextImpl(factory);
TesterBeanB beanB = new TesterBeanB();
beanB.setName("Tomcat");
ValueExpression var =
factory.createValueExpression(beanB, TesterBeanB.class);
context.getVariableMapper().setVariable("beanB", var);
ValueExpression ve = factory.createValueExpression(
context, "${beanB.name}", String.class);
// First check the basics work
String result = (String) ve.getValue(context);
Assert.assertEquals("Tomcat", result);
// Now check the value reference
ValueReference vr = ve.getValueReference(context);
Assert.assertNotNull(vr);
Assert.assertEquals(beanB, vr.getBase());
Assert.assertEquals("name", vr.getProperty());
}
@Test
public void bug56185() {
ExpressionFactory factory = ExpressionFactory.newInstance();
ELContext context = new ELContextImpl();
TesterBeanC beanC = new TesterBeanC();
ValueExpression var =
factory.createValueExpression(beanC, TesterBeanC.class);
context.getVariableMapper().setVariable("myBean", var);
ValueExpression ve = factory.createValueExpression(context,
"${(myBean.int1 > 1 and myBean.myBool) or "+
"((myBean.myBool or myBean.myBool1) and myBean.int1 > 1)}",
Boolean.class);
assertEquals(Boolean.FALSE, ve.getValue(context));
beanC.setInt1(2);
beanC.setMyBool1(true);
assertEquals(Boolean.TRUE, ve.getValue(context));
}
@Override
public Class<?> getType(ELContext context, Object base, Object property) {
if (base == null || this.getCommonPropertyType(context, base) == null) {
return null;
}
context.setPropertyResolved(true);
return Object.class;
}
private void doTestParser(String input, String expectedResult, String expectedBuilderOutput) throws JasperException {
ELException elException = null;
String elResult = null;
// Don't try and evaluate expressions that depend on variables or functions
if (expectedResult != null) {
try {
ExpressionFactory factory = ExpressionFactory.newInstance();
ELContext context = new ELContextImpl();
ValueExpression ve = factory.createValueExpression(context, input, String.class);
elResult = ve.getValue(context).toString();
Assert.assertEquals(expectedResult, elResult);
} catch (ELException ele) {
elException = ele;
}
}
Nodes nodes = null;
try {
nodes = ELParser.parse(input, false);
Assert.assertNull(elException);
} catch (IllegalArgumentException iae) {
Assert.assertNotNull(elResult, elException);
// Not strictly true but enables us to report both
iae.initCause(elException);
throw iae;
}
TextBuilder textBuilder = new TextBuilder(false);
nodes.visit(textBuilder);
Assert.assertEquals(expectedBuilderOutput, textBuilder.getText());
}
@Override
public ValueExpression createValueExpression(ELContext context,
String expression, Class<?> expectedType) {
if (expectedType == null) {
throw new NullPointerException(MessageFactory
.get("error.value.expectedType"));
}
ExpressionBuilder builder = new ExpressionBuilder(expression, context);
return builder.createValueExpression(expectedType);
}
@Override
public boolean isReadOnly(ELContext elContext, Object base, Object property) throws ELException {
if (base == null) {
String beanName = property.toString();
BeanFactory bf = getBeanFactory(elContext);
if (bf.containsBean(beanName)) {
return true;
}
}
return false;
}
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);
}
}
@Override
public Object getValue(ELContext elContext, Object base, Object property) throws ELException {
if (base == null) {
String beanName = property.toString();
BeanFactory bf = getBeanFactory(elContext);
if (bf.containsBean(beanName)) {
if (logger.isTraceEnabled()) {
logger.trace("Successfully resolved variable '" + beanName + "' in Spring BeanFactory");
}
elContext.setPropertyResolved(true);
return bf.getBean(beanName);
}
}
return null;
}
public static final Number coerceToNumber(final ELContext ctx, final Object obj,
final Class<?> type) throws ELException {
if (ctx != null) {
boolean originalIsPropertyResolved = ctx.isPropertyResolved();
try {
Object result = ctx.getELResolver().convertToType(ctx, obj, type);
if (ctx.isPropertyResolved()) {
return (Number) result;
}
} finally {
ctx.setPropertyResolved(originalIsPropertyResolved);
}
}
if (!COERCE_TO_ZERO) {
if (obj == null && !type.isPrimitive()) {
return null;
}
}
if (obj == null || "".equals(obj)) {
return coerceToNumber(ZERO, type);
}
if (obj instanceof String) {
return coerceToNumber((String) obj, type);
}
if (ELArithmetic.isNumber(obj)) {
return coerceToNumber((Number) obj, type);
}
if (obj instanceof Character) {
return coerceToNumber(Short.valueOf((short) ((Character) obj)
.charValue()), type);
}
throw new ELException(MessageFactory.get("error.convert",
obj, obj.getClass(), type));
}
@Override
public Class<?> getType(ELContext context, Object base, Object property) {
if (context == null) {
throw new NullPointerException("context is null");
}
Class<?> result = null;
if (isResolvable(base)) {
result = Node.class;
context.setPropertyResolved(true);
}
return result;
}
@Override
public Object invoke(ELContext context, Object[] params) throws ELException {
context.notifyBeforeEvaluation(getExpressionString());
Object result;
if (this.expectedType != null) {
result = context.convertToType(this.expr, this.expectedType);
} else {
result = this.expr;
}
context.notifyAfterEvaluation(getExpressionString());
return result;
}
private Object evaluateFormatExpression(ELContext context, Object method, Object[] params) {
if (!FORMAT.equals(method)) {
throw new ELException("Wrong method name 'formatter#" + method + "' does not exist. Only formatter#format is supported.");
}
if (params.length == 0) {
throw new ELException("Invalid number of arguments to Formatter#format");
}
if (!(params[0] instanceof String)) {
throw new ELException("The first argument to Formatter#format must be String");
}
FormatterWrapper formatterWrapper = (FormatterWrapper) context.getVariableMapper()
.resolveVariable(FORMATTER)
.getValue(context);
Object[] formattingParameters = new Object[params.length - 1];
System.arraycopy(params, 1, formattingParameters, 0, params.length - 1);
Object returnValue;
try {
returnValue = formatterWrapper.format((String) params[0], formattingParameters);
context.setPropertyResolved(true);
} catch (IllegalFormatException e) {
throw new ELException("Error in Formatter#format call", e);
}
return returnValue;
}
@Override
public ELContext getELContext() {
if (elContext == null) {
elContext = new ELContextWrapper(rootJspCtxt.getELContext(), jspTag, this);
JspFactory factory = JspFactory.getDefaultFactory();
JspApplicationContext jspAppCtxt = factory.getJspApplicationContext(servletContext);
if (jspAppCtxt instanceof JspApplicationContextImpl) {
((JspApplicationContextImpl) jspAppCtxt).fireListeners(elContext);
}
}
return elContext;
}
private ELContext setUpElContextWithContext(final Map<String, Object> context, final String testRule) {
final List<TestBucket> buckets = TestProctorUtils.fromCompactBucketFormat("inactive:-1,control:0,test:1");
final ConsumableTestDefinition testDefVal1 = TestProctorUtils.constructDefinition(buckets,
TestProctorUtils.fromCompactAllocationFormat(String.format("%s|-1:0.5,0:0.5,1:0.0", testRule), "-1:0.25,0:0.5,1:0.25"));
final Map<String, ValueExpression> testConstants = ProctorUtils.convertToValueExpressionMap(expressionFactory, testDefVal1.getConstants());
final ProvidedContext providedContext = ProvidedContext.forValueExpressionMap(ProctorUtils.convertToValueExpressionMap(expressionFactory, context), Collections.emptySet());
final VariableMapper variableMapper = new MulticontextReadOnlyVariableMapper(testConstants, providedContext.getContext());
final RuleEvaluator ruleEvaluator = new RuleEvaluator(expressionFactory, RuleEvaluator.FUNCTION_MAPPER, testDefVal1.getConstants());
return ruleEvaluator.createELContext(variableMapper);
}
@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());
}
@Override
public boolean isReadOnly(ELContext context, Object base, Object property) {
Objects.requireNonNull(context);
if (base == null) {
context.setPropertyResolved(base, property);
return true;
}
return elResolver.isReadOnly(context, base, property);
}
@Override
public boolean isReadOnly(ELContext context, Object base, Object property)
throws NullPointerException, PropertyNotFoundException, ELException {
if (context == null) {
throw new NullPointerException();
}
if (base == null) {
context.setPropertyResolved(true);
return true;
}
return elResolver.isReadOnly(context, base, property);
}
@Override
public MethodExpression createMethodExpression(ELContext context,
String expression, Class<?> expectedReturnType,
Class<?>[] expectedParamTypes) {
ExpressionBuilder builder = new ExpressionBuilder(expression, context);
return builder.createMethodExpression(expectedReturnType,
expectedParamTypes);
}
protected ValueExpression transformSimpleUnaryTests(String simpleUnaryTests, String inputName, ELContext elContext) {
String juelExpression = transformToJuelExpression(simpleUnaryTests, inputName);
try {
return expressionFactory.createValueExpression(elContext, juelExpression, Object.class);
}
catch (ELException e) {
throw LOG.invalidExpression(simpleUnaryTests, e);
}
}