init
This commit is contained in:
331
java/org/apache/el/MethodExpressionImpl.java
Normal file
331
java/org/apache/el/MethodExpressionImpl.java
Normal file
@@ -0,0 +1,331 @@
|
||||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one or more
|
||||
* contributor license agreements. See the NOTICE file distributed with
|
||||
* this work for additional information regarding copyright ownership.
|
||||
* The ASF licenses this file to You under the Apache License, Version 2.0
|
||||
* (the "License"); you may not use this file except in compliance with
|
||||
* the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.apache.el;
|
||||
|
||||
import java.io.Externalizable;
|
||||
import java.io.IOException;
|
||||
import java.io.ObjectInput;
|
||||
import java.io.ObjectOutput;
|
||||
|
||||
import javax.el.ELContext;
|
||||
import javax.el.ELException;
|
||||
import javax.el.FunctionMapper;
|
||||
import javax.el.MethodExpression;
|
||||
import javax.el.MethodInfo;
|
||||
import javax.el.MethodNotFoundException;
|
||||
import javax.el.PropertyNotFoundException;
|
||||
import javax.el.VariableMapper;
|
||||
|
||||
import org.apache.el.lang.EvaluationContext;
|
||||
import org.apache.el.lang.ExpressionBuilder;
|
||||
import org.apache.el.parser.Node;
|
||||
import org.apache.el.util.ReflectionUtil;
|
||||
|
||||
|
||||
/**
|
||||
* An <code>Expression</code> that refers to a method on an object.
|
||||
*
|
||||
* <p>
|
||||
* The {@link javax.el.ExpressionFactory#createMethodExpression} method
|
||||
* can be used to parse an expression string and return a concrete instance
|
||||
* of <code>MethodExpression</code> 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.</p>
|
||||
*
|
||||
* <p>The {@link #getMethodInfo} and {@link #invoke} methods will evaluate the
|
||||
* expression each time they are called. The {@link javax.el.ELResolver} in the
|
||||
* <code>ELContext</code> is used to resolve the top-level variables and to
|
||||
* determine the behavior of the <code>.</code> and <code>[]</code>
|
||||
* operators. For any of the two methods, the
|
||||
* {@link javax.el.ELResolver#getValue} method is used to resolve all properties
|
||||
* up to but excluding the last one. This provides the <code>base</code> object
|
||||
* on which the method appears. If the <code>base</code> object is null, a
|
||||
* <code>NullPointerException</code> must be thrown. At the last resolution,
|
||||
* the final <code>property</code> is then coerced to a <code>String</code>,
|
||||
* 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
|
||||
* <code>MethodExpression</code>).</p>
|
||||
*
|
||||
* <p>See the notes about comparison, serialization and immutability in
|
||||
* the {@link javax.el.Expression} javadocs.
|
||||
*
|
||||
* @see javax.el.ELResolver
|
||||
* @see javax.el.Expression
|
||||
* @see javax.el.ExpressionFactory
|
||||
* @see javax.el.MethodExpression
|
||||
*
|
||||
* @author Jacob Hookom [jacob@hookom.net]
|
||||
*/
|
||||
public final class MethodExpressionImpl extends MethodExpression implements
|
||||
Externalizable {
|
||||
|
||||
private Class<?> expectedType;
|
||||
|
||||
private String expr;
|
||||
|
||||
private FunctionMapper fnMapper;
|
||||
|
||||
private VariableMapper varMapper;
|
||||
|
||||
private transient Node node;
|
||||
|
||||
private Class<?>[] paramTypes;
|
||||
|
||||
public MethodExpressionImpl() {
|
||||
super();
|
||||
}
|
||||
|
||||
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
|
||||
* <code>Expression</code>.
|
||||
*
|
||||
* <p>
|
||||
* The result is <code>true</code> if and only if the argument is not
|
||||
* <code>null</code>, is an <code>Expression</code> object that is the
|
||||
* of the same type (<code>ValueExpression</code> or
|
||||
* <code>MethodExpression</code>), and has an identical parsed
|
||||
* representation.
|
||||
* </p>
|
||||
*
|
||||
* <p>
|
||||
* Note that two expressions can be equal if their expression Strings are
|
||||
* different. For example, <code>${fn1:foo()}</code> and
|
||||
* <code>${fn2:foo()}</code> are equal if their corresponding
|
||||
* <code>FunctionMapper</code>s mapped <code>fn1:foo</code> and
|
||||
* <code>fn2:foo</code> to the same method.
|
||||
* </p>
|
||||
*
|
||||
* @param obj
|
||||
* the <code>Object</code> to test for equality.
|
||||
* @return <code>true</code> if <code>obj</code> equals this
|
||||
* <code>Expression</code>; <code>false</code> otherwise.
|
||||
* @see java.util.Hashtable
|
||||
* @see java.lang.Object#equals(java.lang.Object)
|
||||
*/
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
return (obj instanceof MethodExpressionImpl && obj.hashCode() == this
|
||||
.hashCode());
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the original String used to create this <code>Expression</code>,
|
||||
* unmodified.
|
||||
*
|
||||
* <p>
|
||||
* 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).
|
||||
* </p>
|
||||
*
|
||||
* <p>
|
||||
* 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 <code>Expression</code>.
|
||||
* </p>
|
||||
*
|
||||
* @return The original expression String.
|
||||
*
|
||||
* @see javax.el.Expression#getExpressionString()
|
||||
*/
|
||||
@Override
|
||||
public String getExpressionString() {
|
||||
return this.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 <code>MethodInfo</code> containing information
|
||||
* about the method the expression evaluated to.
|
||||
* @throws NullPointerException
|
||||
* if context is <code>null</code> or the base object is
|
||||
* <code>null</code> 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 javax.el.MethodExpression#getMethodInfo(javax.el.ELContext)
|
||||
*/
|
||||
@Override
|
||||
public MethodInfo getMethodInfo(ELContext context)
|
||||
throws PropertyNotFoundException, MethodNotFoundException,
|
||||
ELException {
|
||||
Node n = this.getNode();
|
||||
EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
|
||||
this.varMapper);
|
||||
ctx.notifyBeforeEvaluation(getExpressionString());
|
||||
MethodInfo result = n.getMethodInfo(ctx, this.paramTypes);
|
||||
ctx.notifyAfterEvaluation(getExpressionString());
|
||||
return result;
|
||||
}
|
||||
|
||||
private Node getNode() throws ELException {
|
||||
if (this.node == null) {
|
||||
this.node = ExpressionBuilder.createNode(this.expr);
|
||||
}
|
||||
return this.node;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the hash code for this <code>Expression</code>.
|
||||
*
|
||||
* <p>
|
||||
* 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 <code>equals(Object)</code> method,
|
||||
* then calling the <code>hashCode</code> method on each of the two
|
||||
* objects must produce the same integer result. Implementations must take
|
||||
* special note and implement <code>hashCode</code> correctly.
|
||||
* </p>
|
||||
*
|
||||
* @return The hash code for this <code>Expression</code>.
|
||||
* @see #equals
|
||||
* @see java.util.Hashtable
|
||||
* @see java.lang.Object#hashCode()
|
||||
*/
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return this.expr.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 <code>null</code>
|
||||
* if no parameters.
|
||||
* @return the result of the method invocation (<code>null</code> if the
|
||||
* method has a <code>void</code> return type).
|
||||
* @throws NullPointerException
|
||||
* if context is <code>null</code> or the base object is
|
||||
* <code>null</code> 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 <code>InvocationTargetException</code>,
|
||||
* extract its <code>cause</code> and pass it to the
|
||||
* <code>ELException</code> constructor.
|
||||
* @see javax.el.MethodExpression#invoke(javax.el.ELContext,
|
||||
* java.lang.Object[])
|
||||
*/
|
||||
@Override
|
||||
public Object invoke(ELContext context, Object[] params)
|
||||
throws PropertyNotFoundException, MethodNotFoundException,
|
||||
ELException {
|
||||
EvaluationContext ctx = new EvaluationContext(context, this.fnMapper,
|
||||
this.varMapper);
|
||||
ctx.notifyBeforeEvaluation(getExpressionString());
|
||||
Object result = this.getNode().invoke(ctx, this.paramTypes, params);
|
||||
ctx.notifyAfterEvaluation(getExpressionString());
|
||||
return result;
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see java.io.Externalizable#readExternal(java.io.ObjectInput)
|
||||
*/
|
||||
@Override
|
||||
public void readExternal(ObjectInput in) throws IOException,
|
||||
ClassNotFoundException {
|
||||
this.expr = in.readUTF();
|
||||
String type = in.readUTF();
|
||||
if (!"".equals(type)) {
|
||||
this.expectedType = ReflectionUtil.forName(type);
|
||||
}
|
||||
this.paramTypes = ReflectionUtil.toTypeArray(((String[]) in
|
||||
.readObject()));
|
||||
this.fnMapper = (FunctionMapper) in.readObject();
|
||||
this.varMapper = (VariableMapper) in.readObject();
|
||||
}
|
||||
|
||||
/*
|
||||
* (non-Javadoc)
|
||||
*
|
||||
* @see java.io.Externalizable#writeExternal(java.io.ObjectOutput)
|
||||
*/
|
||||
@Override
|
||||
public void writeExternal(ObjectOutput out) throws IOException {
|
||||
out.writeUTF(this.expr);
|
||||
out.writeUTF((this.expectedType != null) ? this.expectedType.getName()
|
||||
: "");
|
||||
out.writeObject(ReflectionUtil.toTypeNameArray(this.paramTypes));
|
||||
out.writeObject(this.fnMapper);
|
||||
out.writeObject(this.varMapper);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isLiteralText() {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @since EL 3.0
|
||||
*/
|
||||
@Override
|
||||
public boolean isParametersProvided() {
|
||||
return this.getNode().isParametersProvided();
|
||||
}
|
||||
|
||||
/**
|
||||
* @since EL 2.2
|
||||
* Note: The spelling mistake is deliberate.
|
||||
* isParmetersProvided() - Specification definition
|
||||
* isParametersProvided() - Corrected spelling
|
||||
*/
|
||||
@Override
|
||||
public boolean isParmetersProvided() {
|
||||
return this.getNode().isParametersProvided();
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user