PropertyResolverImpl xref

View Javadoc

    1   /*
    2    * $Id: PropertyResolverImpl.java 471754 2006-11-06 14:55:09Z husted $
    3    *
    4    * Licensed to the Apache Software Foundation (ASF) under one
    5    * or more contributor license agreements.  See the NOTICE file
    6    * distributed with this work for additional information
    7    * regarding copyright ownership.  The ASF licenses this file
    8    * to you under the Apache License, Version 2.0 (the
    9    * "License"); you may not use this file except in compliance
    10   * with the License.  You may obtain a copy of the License at
    11   *
    12   *  http://www.apache.org/licenses/LICENSE-2.0
    13   *
    14   * Unless required by applicable law or agreed to in writing,
    15   * software distributed under the License is distributed on an
    16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    17   * KIND, either express or implied.  See the License for the
    18   * specific language governing permissions and limitations
    19   * under the License.
    20   */
    21
    22  package org.apache.struts.faces.application;
    23
    24
    25  import java.util.Map;
    26
    27  import javax.faces.el.PropertyNotFoundException;
    28  import javax.faces.el.PropertyResolver;
    29
    30  import org.apache.commons.beanutils.DynaBean;
    31  import org.apache.commons.beanutils.DynaProperty;
    32  import org.apache.commons.logging.Log;
    33  import org.apache.commons.logging.LogFactory;
    34  import org.apache.struts.action.DynaActionForm;
    35
    36
    37
    38  /**
    39   * <p>Custom <code>PropertyResolver</code> implementation that adds support
    40   * for <code>DynaBean</code> property access to the facilities of the default
    41   * <code>PropertyResolver</code> provided by JavaServer Faces.</p>
    42   *
    43   * <p>This class implements the following specific rules:</p>
    44   * <ul>
    45   * <li>Indexed variants of each call are directly passed through to the
    46   *     <code>PropertyResolver</code> instance that we are wrapping.</li>
    47   * <li>If the specified base object is an instance of
    48   *     <code>DynaActionForm</code>, and the requested property name is
    49   *     <code>map</code>, maintain compatibility with the way that JSP and
    50   *     JSTL expressions can access this property:
    51   *     <ul>
    52   *     <li><code>getValue()</code> will return the result of calling
    53   *         <code>getMap()</code> on the base object.</li>
    54   *     <li><code>setValue()</code> will throw an exception, because the
    55   *         map of property values is a read-only property of the
    56   *         <code>DynaActionForm</code> class.</li>
    57   *     <li><code>isReadOnly()</code> returns <code>true</code>.</li>
    58   *     <li><code>getType()</code> returns the <code>Class</code> object
    59   *         for <code>java.util.Map</code>.</li>
    60   *     </ul></li>
    61   * <li>If the specified base object is an instance of
    62   *     <code>DynaBean</code>, provide access to its named properties
    63   *     as follows:
    64   *     <ul>
    65   *     <li><code>getValue()</code> will return the result of calling
    66   *         <code>get()</code> on the base object.</li>
    67   *     <li><code>setValue()</code> will call <code>set()</code>
    68   *         on the base object.</li>
    69   *     <li><code>isReadOnly()</code> returns <code>false</code> (because
    70   *         the DynaBean APIs provide no mechanism to make this determination,
    71   *         but most implementations will provide mutable properties).</li>
    72   *     <li><code>getType()</code> returns the <code>Class</code> object
    73   *         for the underlying dynamic property.</li>
    74   *     </ul></li>
    75   * <li>Named variant calls with any other type of base object are
    76   *     passed through to the <code>PropertyResolver</code> that we
    77   *     are wrapping.</li>
    78   * </ul>
    79   *
    80   * @version $Rev: 471754 $ $Date: 2006-11-06 08:55:09 -0600 (Mon, 06 Nov 2006) $
    81   */
    82
    83  public class PropertyResolverImpl extends PropertyResolver {
    84
    85
    86      // ------------------------------------------------------------ Constructor
    87
    88
    89      /**
    90       * <p>Construct a new <code>PropertyResolver</code> instance, wrapping the
    91       * specified instance using the Decorator pattern such that this class need
    92       * implement only the new functionality it supports, and not need to
    93       * re-implement the basic facilities.
    94       *
    95       * @param resolver The original resolver to be wrapped
    96       *
    97       * @exception NullPointerException if <code>resolver</code>
    98       *  is <code>null</code>
    99       */
    100     public PropertyResolverImpl(PropertyResolver resolver) {
    101
    102         if (resolver == null) {
    103             throw new NullPointerException();
    104         }
    105         if (log.isDebugEnabled()) {
    106             log.debug("Creating new instance, wrapping resolver " +
    107                       resolver);
    108         }
    109         this.resolver = resolver;
    110
    111     }
    112
    113
    114     // ----------------------------------------------------- Instance Variables
    115
    116
    117     /**
    118      * <p>The <code>Log</code> instance for this class.</p>
    119      */
    120     private static final Log log =
    121         LogFactory.getLog(PropertyResolverImpl.class);
    122
    123
    124     /**
    125      * <p>The <code>PropertyResolver</code> instance that we are wrapping,
    126      * which will be used to perform operations on beans that are not
    127      * recognized by this class.</p>
    128      */
    129     private PropertyResolver resolver = null;
    130
    131
    132     // ----------------------------------------------- PropertyResolver Methods
    133
    134
    135     /**
    136      * <p>Return the value of the property with the specified name from
    137      * the specified base object.</p>
    138      *
    139      * @param base The base object whose property value is to be returned
    140      * @param name Name of the property to be returned
    141      *
    142      * @exception NullPointerException if <code>base</code> or
    143      *  <code>name</code> is <code>null</code>
    144      * @exception PropertyNotFoundException if the specified property name
    145      *  does not exist, or is not readable
    146      */
    147     public Object getValue(Object base, Object name)
    148         throws PropertyNotFoundException {
    149
    150         if ((base == null) || (name == null)) {
    151             throw new NullPointerException();
    152         } else if ((base instanceof DynaActionForm) &&
    153                    ("map".equals(name))) {
    154             if (log.isTraceEnabled()) {
    155                 log.trace("Returning property map for DynaActionForm " + base
    156                           + "'");
    157             }
    158             return (((DynaActionForm) base).getMap());
    159         } else if (base instanceof DynaBean) {
    160             if (getDynaProperty((DynaBean) base, name.toString()) == null) {
    161                 throw new PropertyNotFoundException(name.toString());
    162             }
    163             Object value = ((DynaBean) base).get(name.toString());
    164             if (log.isTraceEnabled()) {
    165                 log.trace("Returning dynamic property '" + name +
    166                           "' for DynaBean '" + base + "' value '" +
    167                           value + "'");
    168             }
    169             return (value);
    170         } else {
    171             Object value = resolver.getValue(base, name);
    172             if (log.isTraceEnabled()) {
    173                 log.trace("Delegating get of property '" + name +
    174                           "' for bean '" + base + "' value '" +
    175                           value + "'");
    176             }
    177             return (value);
    178         }
    179
    180     }
    181
    182
    183     /**
    184      * <p>Return the value at the specified index of the specified
    185      * base object.</p>
    186      *
    187      * @param base The base object whose property value is to be returned
    188      * @param index Index of the value to return
    189      *
    190      * @exception IndexOutOfBoundsException if thrown by the underlying
    191      *  access to the base object
    192      * @exception NullPointerException if <code>base</code>
    193      *  is <code>null</code>
    194      * @exception PropertyNotFoundException if some other exception occurs
    195      */
    196     public Object getValue(Object base, int index)
    197         throws PropertyNotFoundException {
    198
    199         return (resolver.getValue(base, index));
    200
    201     }
    202
    203
    204     /**
    205      * <p>Set the specified value of the property with the specified name on
    206      * the specified base object.</p>
    207      *
    208      * @param base The base object whose property value is to be set
    209      * @param name Name of the property to be set
    210      * @param value Value of the property to be set
    211      *
    212      * @exception NullPointerException if <code>base</code> or
    213      *  <code>name</code> is <code>null</code>
    214      * @exception PropertyNotFoundException if the specified property name
    215      *  does not exist, or is not writeable
    216      */
    217     public void setValue(Object base, Object name, Object value)
    218         throws PropertyNotFoundException {
    219
    220         if ((base == null) || (name == null)) {
    221             throw new NullPointerException();
    222         } else if ((base instanceof DynaActionForm) &&
    223                    ("map".equals(name))) {
    224             throw new PropertyNotFoundException(name.toString());
    225         } else if (base instanceof DynaBean) {
    226             if (log.isTraceEnabled()) {
    227                 log.trace("setting dynamic property '" + name +
    228                           "' for DynaBean '" + base +
    229                           "' to '" + value + "'");
    230             }
    231             if (getDynaProperty((DynaBean) base, name.toString()) == null) {
    232                 throw new PropertyNotFoundException(name.toString());
    233             }
    234             ((DynaBean) base).set(name.toString(), value);
    235         } else {
    236             if (log.isTraceEnabled()) {
    237                 log.trace("Delegating set of property '" + name +
    238                           "' for bean '" + base + "' to value '" +
    239                           value + "'");
    240             }
    241             resolver.setValue(base, name, value);
    242         }
    243
    244     }
    245
    246
    247     /**
    248      * <p>Set the value at the specified index of the specified
    249      * base object.</p>
    250      *
    251      * @param base The base object whose property value is to be set
    252      * @param index Index of the value to set
    253      * @param value Value to be set
    254      *
    255      * @exception IndexOutOfBoundsException if thrown by the underlying
    256      *  access to the base object
    257      * @exception NullPointerException if <code>base</code>
    258      *  is <code>null</code>
    259      * @exception PropertyNotFoundException if some other exception occurs
    260      */
    261     public void setValue(Object base, int index, Object value)
    262         throws PropertyNotFoundException {
    263
    264         resolver.setValue(base, index, value);
    265
    266     }
    267
    268
    269     /**
    270      * <p>Return <code>true</code> if the specified property of the specified
    271      * base object is known to be immutable; otherwise, return
    272      * <code>false</code>.</p>
    273      *
    274      * @param base The base object whose property is to analyzed
    275      * @param name Name of the property to be analyzed
    276      *
    277      * @exception NullPointerException if <code>base</code> or
    278      *  <code>name</code> is <code>null</code>
    279      * @exception PropertyNotFoundException if the specified property name
    280      *  does not exist
    281      */
    282     public boolean isReadOnly(Object base, Object name)
    283         throws PropertyNotFoundException {
    284
    285         if ((base == null) || (name == null)) {
    286             throw new NullPointerException();
    287         } else if ((base instanceof DynaActionForm) &&
    288                    ("map".equals(name))) {
    289             return (true);
    290         } else if (base instanceof DynaBean) {
    291             if (getDynaProperty((DynaBean) base, name.toString()) == null) {
    292                 throw new PropertyNotFoundException(name.toString());
    293             }
    294             return (false);
    295         } else {
    296             return (resolver.isReadOnly(base, name.toString()));
    297         }
    298
    299     }
    300
    301
    302     /**
    303      * <p>Return <code>true</code> if the value at the specified index of
    304      * the specified base object is known to be immutable; otherwise,
    305      * return <code>false</code>.</p>
    306      *
    307      * @param base The base object whose property is to analyzed
    308      * @param index Index of the value whose type is to be returned
    309      *
    310      * @exception IndexOutOfBoundsException if thrown by the underlying
    311      *  accessed to the indexed property
    312      * @exception NullPointerException if <code>base</code>
    313      *  is <code>null</code>
    314      * @exception PropertyNotFoundException if some other exception occurs
    315      */
    316     public boolean isReadOnly(Object base, int index)
    317         throws PropertyNotFoundException {
    318
    319         return (resolver.isReadOnly(base, index));
    320
    321     }
    322
    323
    324     /**
    325      * <p>Return the <code>java.lang.Class</code> representing the type of
    326      * the specified property of the specified base object, if it can be
    327      * determined; otherwise return <code>null</code>.</p>
    328      *
    329      * @param base The base object whose property is to analyzed
    330      * @param name Name of the property to be analyzed
    331      *
    332      * @exception NullPointerException if <code>base</code> or
    333      *  <code>name</code> is <code>null</code>
    334      * @exception PropertyNotFoundException if the specified property name
    335      *  does not exist
    336      */
    337     public Class getType(Object base, Object name)
    338         throws PropertyNotFoundException {
    339
    340         if ((base == null) || (name == null)) {
    341             throw new NullPointerException();
    342         } else if ((base instanceof DynaActionForm) &&
    343                    ("map".equals(name))) {
    344             return (Map.class);
    345         } else if (base instanceof DynaBean) {
    346             DynaProperty dynaProperty =
    347                 getDynaProperty((DynaBean) base, name.toString());
    348             if (dynaProperty != null) {
    349                 return (dynaProperty.getType());
    350             } else {
    351                 throw new PropertyNotFoundException(name.toString());
    352             }
    353         } else {
    354             return (resolver.getType(base, name));
    355         }
    356     }
    357
    358
    359     /**
    360      * <p>Return the <code>java.lang.Class</code> representing the type of
    361      * value at the specified index of the specified base object, or
    362      * <code>null</code> if this value is <code>null</code>.</p>
    363      *
    364      * @param base The base object whose property is to analyzed
    365      * @param index Index of the value whose type is to be returned
    366      *
    367      * @exception IndexOutOfBoundsException if thrown by the underlying
    368      *  accessed to the indexed property
    369      * @exception NullPointerException if <code>base</code>
    370      *  is <code>null</code>
    371      * @exception PropertyNotFoundException if some other exception occurs
    372      */
    373     public Class getType(Object base, int index)
    374         throws PropertyNotFoundException {
    375
    376         return (resolver.getType(base, index));
    377
    378     }
    379
    380
    381     // -------------------------------------------------------- Private Methods
    382
    383
    384     /**
    385      * <p>Return the <code>DynaProperty</code> describing the specified
    386      * property of the specified <code>DynaBean</code>, or <code>null</code>
    387      * if there is no such property defined on the underlying
    388      * <code>DynaClass</code>.</p>
    389      *
    390      * @param bean <code>DynaBean</code> to be checked
    391      * @param name Name of the property to be checked
    392      */
    393     private DynaProperty getDynaProperty(DynaBean bean, String name)
    394         throws PropertyNotFoundException {
    395
    396         DynaProperty dynaProperty = null;
    397         try {
    398             dynaProperty = bean.getDynaClass().getDynaProperty(name);
    399         } catch (IllegalArgumentException e) {
    400             ;
    401         }
    402         return (dynaProperty);
    403
    404     }
    405
    406
    407
    408
    409 }