elresolver.java

java属性邦定的（JSR-295）的一个实现

/*
 * Copyright (C) 2007 Sun Microsystems, Inc. All rights reserved. Use is
 * subject to license terms.
 */

package org.jdesktop.el;

import java.util.Iterator;
import java.beans.FeatureDescriptor;

/**
 * Enables customization of variable and property resolution behavior for EL
 * expression evaluation.
 *
 * <p>While evaluating an expression, the <code>ELResolver</code> associated
 * with the {@link ELContext} is consulted to do the initial resolution of 
 * the first variable of an expression. It is also consulted when a 
 * <code>.</code> or <code>[]</code> operator is encountered, except for the
 * last such operator in a method expression, in which case the resultion
 * rules are hard coded.</p>
 *
 * <p>For example, in the EL expression <code>${employee.lastName}</code>, 
 * the <code>ELResolver</code> determines what object <code>employee</code>
 * refers to, and what it means to get the <code>lastName</code> property on 
 * that object.</p>
 *
 * <p>Most methods in this class accept a <code>base</code> 
 * and <code>property</code> parameter. In the case of variable resolution
 * (e.g. determining what <code>employee</code> refers to in 
 * <code>${employee.lastName}</code>), the <code>base</code> parameter will 
 * be <code>null</code> and the <code>property</code> parameter will always 
 * be of type <code>String</code>. In this case, if the <code>property</code>
 * is not a <code>String</code>, the behavior of the <code>ELResolver</code>
 * is undefined.</p>
 *
 * <p>In the case of property resolution, the <code>base</code> parameter
 * identifies the base object and the <code>property</code> object identifies
 * the property on that base. For example, in the expression
 * <code>${employee.lastName}</code>, <code>base</code> is the result of the
 * variable resolution for <code>employee</code> and <code>property</code>
 * is the string <code>"lastName"</code>.  In the expression
 * <code>${y[x]}</code>, <code>base</code> is the result of the variable
 * resolution for <code>y</code> and <code>property</code> is the result of
 * the variable resolution for <code>x</code>.</p>
 *
 * <p>Though only a single <code>ELResolver</code> is associated with an
 * <code>ELContext</code>, there are usually multiple resolvers considered
 * for any given variable or property resolution. <code>ELResolver</code>s
 * are combined together using {@link CompositeELResolver}s, to define
 * rich semantics for evaluating an expression.</p>
 *
 * <p>For the {@link #getValue}, {@link #getType}, {@link #setValue} and
 * {@link #isReadOnly} methods, an <code>ELResolver</code> is not
 * responsible for resolving all possible (base, property) pairs. In fact,
 * most resolvers will only handle a <code>base</code> of a single type.
 * To indicate that a resolver has successfully resolved a particular
 * (base, property) pair, it must set the <code>propertyResolved</code>
 * property of the <code>ELContext</code> to <code>true</code>. If it could 
 * not handle the given pair, it must leave this property alone. The caller
 * must ignore the return value of the method if <code>propertyResolved</code>
 * is <code>false</code>.</p>
 *
 * <p>The {@link #getFeatureDescriptors} and {@link #getCommonPropertyType}
 * methods are primarily designed for design-time tool support, but must
 * handle invocation at runtime as well. The 
 * {@link java.beans.Beans#isDesignTime} method can be used to determine 
 * if the resolver is being consulted at design-time or runtime.</p>
 *
 * @see CompositeELResolver
 * @see ELContext#getELResolver
 * @since JSP 2.1
 */
public abstract class ELResolver {
    
    // --------------------------------------------------------- Constants

    /**
     * <p>The attribute name of the named attribute in the
     * <code>FeatureDescriptor</code> that specifies the runtime type of
     * the variable or property.</p>
     */

    public static final String TYPE = "type";

    /**
     * <p>The attribute name of the named attribute in the
     * <code>FeatureDescriptor</code> that specifies whether the
     * variable or property can be resolved at runtime.</p>
     */

    public static final String RESOLVABLE_AT_DESIGN_TIME = "resolvableAtDesignTime";

    /**
     * Attempts to resolve the given <code>property</code> object on the given
     * <code>base</code> object.
     *
     * <p>If this resolver handles the given (base, property) pair, 
     * the <code>propertyResolved</code> property of the 
     * <code>ELContext</code> object must be set to <code>true</code>
     * by the resolver, before returning. If this property is not 
     * <code>true</code> after this method is called, the caller should ignore 
     * the return value.</p>
     *
     * @param context The context of this evaluation.
     * @param base The base object whose property value is to be returned,
     *     or <code>null</code> to resolve a top-level variable.
     * @param property The property or variable to be resolved.
     * @return If the <code>propertyResolved</code> property of 
     *     <code>ELContext</code> was set to <code>true</code>, then
     *     the result of the variable or property resolution; otherwise
     *     undefined.
     * @throws NullPointerException if context is <code>null</code>
     * @throws PropertyNotFoundException if the given (base, property) pair
     *     is handled by this <code>ELResolver</code> but the specified
     *     variable or property does not exist or is not readable.
     * @throws ELException if an exception was thrown while performing
     *     the property or variable resolution. The thrown exception
     *     must be included as the cause property of this exception, if
     *     available.
     */
    public abstract Object getValue(ELContext context,
                                    Object base,
                                    Object property);

    /**
     * For a given <code>base</code> and <code>property</code>, attempts to
     * identify the most general type that is acceptable for an object to be 
     * passed as the <code>value</code> parameter in a future call 
     * to the {@link #setValue} method.
     *
     * <p>If this resolver handles the given (base, property) pair, 
     * the <code>propertyResolved</code> property of the 
     * <code>ELContext</code> object must be set to <code>true</code>
     * by the resolver, before returning. If this property is not 
     * <code>true</code> after this method is called, the caller should ignore 
     * the return value.</p>
     *
     * <p>This is not always the same as <code>getValue().getClass()</code>.
     * For example, in the case of an {@link ArrayELResolver}, the
     * <code>getType</code> method will return the element type of the 
     * array, which might be a superclass of the type of the actual 
     * element that is currently in the specified array element.</p>
     *
     * @param context The context of this evaluation.
     * @param base The base object whose property value is to be analyzed,
     *     or <code>null</code> to analyze a top-level variable.
     * @param property The property or variable to return the acceptable 
     *     type for.
     * @return If the <code>propertyResolved</code> property of 
     *     <code>ELContext</code> was set to <code>true</code>, then
     *     the most general acceptable type; otherwise undefined.
     * @throws NullPointerException if context is <code>null</code>
     * @throws PropertyNotFoundException if the given (base, property) pair
     *     is handled by this <code>ELResolver</code> but the specified
     *     variable or property does not exist or is not readable.
     * @throws ELException if an exception was thrown while performing
     *     the property or variable resolution. The thrown exception
     *     must be included as the cause property of this exception, if
     *     available.
     */
    public abstract Class<?> getType(ELContext context,
                                  Object base,
                                  Object property);