com.sun.el.MethodExpressionImpl Maven / Gradle / Ivy
Show all versions of jakarta.el Show documentation
/*
* Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0, which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception, which is available at
* https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
*/
package com.sun.el;
import static com.sun.el.util.ReflectionUtil.forName;
import static com.sun.el.util.ReflectionUtil.toTypeArray;
import static com.sun.el.util.ReflectionUtil.toTypeNameArray;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import jakarta.el.ELContext;
import jakarta.el.ELException;
import jakarta.el.ELResolver;
import jakarta.el.Expression;
import jakarta.el.ExpressionFactory;
import jakarta.el.FunctionMapper;
import jakarta.el.MethodExpression;
import jakarta.el.MethodInfo;
import jakarta.el.MethodNotFoundException;
import jakarta.el.PropertyNotFoundException;
import jakarta.el.VariableMapper;
import com.sun.el.lang.EvaluationContext;
import com.sun.el.lang.ExpressionBuilder;
import com.sun.el.parser.Node;
/**
* An Expression that refers to a method on an object.
*
*
* The {@link ExpressionFactory#createMethodExpression} method can be used to parse an expression string and return a
* concrete instance of MethodExpression that encapsulates the parsed expression. The
* {@link FunctionMapper} is used at parse time, not evaluation time, so one is not needed to evaluate an expression
* using this class. However, the {@link ELContext} is needed at evaluation time.
*
*
*
* The {@link #getMethodInfo} and {@link #invoke} methods will evaluate the expression each time they are called. The
* {@link ELResolver} in the ELContext is used to resolve the top-level variables and to determine the
* behavior of the . and [] operators. For any of the two methods, the
* {@link ELResolver#getValue} method is used to resolve all properties up to but excluding the last one. This provides
* the base object on which the method appears. If the base object is null, a
* NullPointerException must be thrown. At the last resolution, the final property is then
* coerced to a String, which provides the name of the method to be found. A method matching the name and
* expected parameters provided at parse time is found and it is either queried or invoked (depending on the method
* called on this MethodExpression).
*
*
*
* See the notes about comparison, serialization and immutability in the {@link Expression} javadocs.
*
* @see ELResolver
* @see Expression
* @see ExpressionFactory
* @see MethodExpression
*
* @author Jacob Hookom [[email protected]]
* @version $Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author: kchung $
*/
public final class MethodExpressionImpl extends MethodExpression implements Externalizable {
private Class expectedType;
private String expr;
private FunctionMapper fnMapper;
private VariableMapper varMapper;
private Class[] paramTypes;
private transient Node node;
public MethodExpressionImpl() {
super();
}
/**
* @param expr the expression
* @param node the node
* @param fnMapper the function mapper
* @param varMapper the variable mapper
* @param expectedType expected return type of method
* @param paramTypes the method parameters
*/
public MethodExpressionImpl(String expr, Node node, FunctionMapper fnMapper, VariableMapper varMapper, Class expectedType, Class[] paramTypes) {
super();
this.expr = expr;
this.node = node;
this.fnMapper = fnMapper;
this.varMapper = varMapper;
this.expectedType = expectedType;
this.paramTypes = paramTypes;
}
/**
* Determines whether the specified object is equal to this Expression.
*
*
* The result is true if and only if the argument is not null, is an Expression
* object that is the of the same type (ValueExpression or MethodExpression), and has an
* identical parsed representation.
*
*
*
* Note that two expressions can be equal if their expression Strings are different. For example,
* ${fn1:foo()} and ${fn2:foo()} are equal if their corresponding FunctionMappers
* mapped fn1:foo and fn2:foo to the same method.
*
*
* @param obj the Object to test for equality.
* @return true if obj equals this Expression; false otherwise.
* @see java.util.Hashtable
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(Object obj) {
if (obj instanceof MethodExpressionImpl) {
MethodExpressionImpl methodExpressionImpl = (MethodExpressionImpl) obj;
return getNode().equals(methodExpressionImpl.getNode());
}
return false;
}
/**
* Returns the original String used to create this Expression, unmodified.
*
*
* This is used for debugging purposes but also for the purposes of comparison (e.g. to ensure the expression in a
* configuration file has not changed).
*
*
*
* This method does not provide sufficient information to re-create an expression. Two different expressions can have
* exactly the same expression string but different function mappings. Serialization should be used to save and restore
* the state of an Expression.
*
*
* @return The original expression String.
*
* @see Expression#getExpressionString()
*/
@Override
public String getExpressionString() {
return expr;
}
/**
* Evaluates the expression relative to the provided context, and returns information about the actual referenced
* method.
*
* @param context The context of this evaluation
* @return an instance of MethodInfo containing information about the method the expression evaluated to.
* @throws NullPointerException if context is null or the base object is null on the last
* resolution.
* @throws PropertyNotFoundException if one of the property resolutions failed because a specified variable or property
* does not exist or is not readable.
* @throws MethodNotFoundException if no suitable method can be found.
* @throws ELException if an exception was thrown while performing property or variable resolution. The thrown exception
* must be included as the cause property of this exception, if available.
* @see MethodExpression#getMethodInfo(ELContext)
*/
@Override
public MethodInfo getMethodInfo(ELContext context) throws PropertyNotFoundException, MethodNotFoundException, ELException {
return getNode().getMethodInfo(new EvaluationContext(context, fnMapper, varMapper), paramTypes);
}
/**
* @return The Node for the expression
* @throws ELException
*/
private Node getNode() throws ELException {
if (node == null) {
node = ExpressionBuilder.createNode(expr);
}
return node;
}
/**
* Returns the hash code for this Expression.
*
*
* See the note in the {@link #equals} method on how two expressions can be equal if their expression Strings are
* different. Recall that if two objects are equal according to the equals(Object) method, then calling the
* hashCode method on each of the two objects must produce the same integer result. Implementations must
* take special note and implement hashCode correctly.
*
*
* @return The hash code for this Expression.
* @see #equals
* @see java.util.Hashtable
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
return getNode().hashCode();
}
/**
* Evaluates the expression relative to the provided context, invokes the method that was found using the supplied
* parameters, and returns the result of the method invocation.
*
* @param context The context of this evaluation.
* @param params The parameters to pass to the method, or null if no parameters.
* @return the result of the method invocation (null if the method has a void return type).
* @throws NullPointerException if context is null or the base object is null on the last
* resolution.
* @throws PropertyNotFoundException if one of the property resolutions failed because a specified variable or property
* does not exist or is not readable.
* @throws MethodNotFoundException if no suitable method can be found.
* @throws ELException if an exception was thrown while performing property or variable resolution. The thrown exception
* must be included as the cause property of this exception, if available. If the exception thrown is an
* InvocationTargetException, extract its cause and pass it to the ELException
* constructor.
* @see MethodExpression#invoke(ELContext, java.lang.Object[])
*/
@Override
public Object invoke(ELContext context, Object[] params) throws PropertyNotFoundException, MethodNotFoundException, ELException {
EvaluationContext ctx = new EvaluationContext(context, fnMapper, varMapper);
ctx.notifyBeforeEvaluation(expr);
Object obj = getNode().invoke(ctx, paramTypes, params);
ctx.notifyAfterEvaluation(expr);
return obj;
}
/*
* (non-Javadoc)
*
* @see java.io.Externalizable#readExternal(java.io.ObjectInput)
*/
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
expr = in.readUTF();
String type = in.readUTF();
if (!"".equals(type)) {
expectedType = forName(type);
}
paramTypes = toTypeArray(((String[]) in.readObject()));
fnMapper = (FunctionMapper) in.readObject();
varMapper = (VariableMapper) in.readObject();
}
/*
* (non-Javadoc)
*
* @see java.io.Externalizable#writeExternal(java.io.ObjectOutput)
*/
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeUTF(expr);
out.writeUTF(expectedType != null ? expectedType.getName() : "");
out.writeObject(toTypeNameArray(paramTypes));
out.writeObject(fnMapper);
out.writeObject(varMapper);
}
@Override
public boolean isLiteralText() {
return false;
}
@Override
public boolean isParametersProvided() {
return getNode().isParametersProvided();
}
}