DefinitionsUtil xref

View Javadoc

    1   /*
    2    * $Id: DefinitionsUtil.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.tiles;
    23
    24  import java.lang.reflect.InvocationTargetException;
    25  import java.util.Enumeration;
    26  import java.util.HashMap;
    27  import java.util.Map;
    28
    29  import javax.servlet.ServletConfig;
    30  import javax.servlet.ServletContext;
    31  import javax.servlet.ServletRequest;
    32
    33  import org.apache.commons.logging.Log;
    34  import org.apache.commons.logging.LogFactory;
    35  import org.apache.struts.tiles.taglib.ComponentConstants;
    36
    37  /**
    38   * Utilities class for definitions factory.
    39   * Also define userDebugLevel property (TODO to be moved from this class ?).
    40   * @deprecated Use {@link TilesUtil#createDefinitionsFactory(ServletContext, DefinitionsFactoryConfig)}
    41   */
    42  public class DefinitionsUtil extends TilesUtil implements ComponentConstants {
    43
    44      /**
    45       * Commons Logging instance.
    46       */
    47      protected static Log log = LogFactory.getLog(DefinitionsUtil.class);
    48
    49      /**
    50       * Global user defined debug level.
    51       * @deprecated This will be removed in a release after Struts 1.2.
    52       */
    53      public static int userDebugLevel = 0;
    54
    55      /**
    56       * User Debug level.
    57       * @deprecated This will be removed in a release after Struts 1.2.
    58       */
    59      public static final int NO_DEBUG = 0;
    60
    61      /**
    62       * Name of init property carrying debug level.
    63       */
    64      public static final String DEFINITIONS_CONFIG_USER_DEBUG_LEVEL =
    65          "definitions-debug";
    66
    67      /**
    68       * Name of init property carrying factory class name.
    69       */
    70      public static final String DEFINITIONS_FACTORY_CLASSNAME =
    71          "definitions-factory-class";
    72
    73      /**
    74       * Constant name used to store factory in context.
    75       */
    76      public static final String DEFINITIONS_FACTORY =
    77          "org.apache.struts.tiles.DEFINITIONS_FACTORY";
    78
    79      /**
    80       * Constant name used to store definition in jsp context.
    81       * Used to pass definition from a Struts action to servlet forward.
    82       */
    83      public static final String ACTION_DEFINITION =
    84          "org.apache.struts.tiles.ACTION_DEFINITION";
    85
    86      /**
    87       * Create Definition factory.
    88       * If a factory class name is provided, a factory of this class is created. Otherwise,
    89       * default factory is created.
    90       * @param classname Class name of the factory to create.
    91       * @param servletContext Servlet Context passed to newly created factory.
    92       * @param properties Map of name/property used to initialize factory configuration object.
    93       * @return newly created factory.
    94       * @throws DefinitionsFactoryException If an error occur while initializing factory
    95       * @deprecated Use createDefinitionsFactory(ServletContext servletContext, ServletConfig servletConfig)
    96       */
    97      public static DefinitionsFactory createDefinitionsFactory(
    98          ServletContext servletContext,
    99          Map properties,
    100         String classname)
    101         throws DefinitionsFactoryException {
    102
    103         // Create config object
    104         DefinitionsFactoryConfig factoryConfig = new DefinitionsFactoryConfig();
    105         // populate it from map.
    106         try {
    107             factoryConfig.populate(properties);
    108
    109         } catch (Exception ex) {
    110             throw new DefinitionsFactoryException(
    111                 "Error - createDefinitionsFactory : Can't populate config object from properties map",
    112                 ex);
    113         }
    114
    115         // Add classname
    116         if (classname != null)
    117             factoryConfig.setFactoryClassname(classname);
    118
    119         // Create factory using config object
    120         return createDefinitionsFactory(servletContext, factoryConfig);
    121     }
    122
    123     /**
    124      * Create default Definition factory.
    125      * @param servletContext Servlet Context passed to newly created factory.
    126      * @param properties Map of name/property used to initialize factory configuration object.
    127      * @return newly created factory of type ConfigurableDefinitionsFactory.
    128      * @throws DefinitionsFactoryException If an error occur while initializing factory
    129      */
    130     public static DefinitionsFactory createDefinitionsFactory(
    131         ServletContext servletContext,
    132         Map properties)
    133         throws DefinitionsFactoryException {
    134
    135         return createDefinitionsFactory(servletContext, properties, null);
    136     }
    137
    138     /**
    139      * Create Definition factory.
    140      * Create configuration object from servlet web.xml file, then create
    141      * ConfigurableDefinitionsFactory and initialized it with object.
    142      * <p>
    143      * Convenience method. Calls createDefinitionsFactory(ServletContext servletContext, DefinitionsFactoryConfig factoryConfig)
    144      *
    145      * @param servletContext Servlet Context passed to newly created factory.
    146      * @param servletConfig Servlet config containing parameters to be passed to factory configuration object.
    147      * @return newly created factory of type ConfigurableDefinitionsFactory.
    148      * @throws DefinitionsFactoryException If an error occur while initializing factory
    149      */
    150     public static DefinitionsFactory createDefinitionsFactory(
    151         ServletContext servletContext,
    152         ServletConfig servletConfig)
    153         throws DefinitionsFactoryException {
    154
    155         DefinitionsFactoryConfig factoryConfig = readFactoryConfig(servletConfig);
    156
    157         return createDefinitionsFactory(servletContext, factoryConfig);
    158     }
    159
    160     /**
    161      * Create Definition factory.
    162      * Create configuration object from servlet web.xml file, then create
    163      * ConfigurableDefinitionsFactory and initialized it with object.
    164      * <p>
    165      * If checkIfExist is true, start by checking if factory already exist. If yes,
    166      * return it. If no, create a new one.
    167      * <p>
    168      * If checkIfExist is false, factory is always created.
    169      * <p>
    170      * Convenience method. Calls createDefinitionsFactory(ServletContext servletContext, DefinitionsFactoryConfig factoryConfig)
    171      *
    172      * @param servletContext Servlet Context passed to newly created factory.
    173      * @param servletConfig Servlet config containing parameters to be passed to factory configuration object.
    174      * @param checkIfExist Check if factory already exist. If true and factory exist, return it.
    175      * If true and factory doesn't exist, create it. If false, create it in all cases.
    176      * @return newly created factory of type ConfigurableDefinitionsFactory.
    177      * @throws DefinitionsFactoryException If an error occur while initializing factory
    178      */
    179     public static DefinitionsFactory createDefinitionsFactory(
    180         ServletContext servletContext,
    181         ServletConfig servletConfig,
    182         boolean checkIfExist)
    183         throws DefinitionsFactoryException {
    184
    185         if (checkIfExist) {
    186             // Check if already exist in context
    187             DefinitionsFactory factory = getDefinitionsFactory(servletContext);
    188             if (factory != null)
    189                 return factory;
    190         }
    191
    192         return createDefinitionsFactory(servletContext, servletConfig);
    193     }
    194
    195     /**
    196      * Get definition factory from appropriate servlet context.
    197      * @return Definitions factory or null if not found.
    198      * @deprecated Use {@link TilesUtil#getDefinitionsFactory(ServletRequest, ServletContext)}
    199      * @since 20020708
    200      */
    201     public static DefinitionsFactory getDefinitionsFactory(ServletContext servletContext) {
    202         return (DefinitionsFactory) servletContext.getAttribute(DEFINITIONS_FACTORY);
    203     }
    204
    205     /**
    206      * Get Definition stored in jsp context by an action.
    207      * @return ComponentDefinition or null if not found.
    208      */
    209     public static ComponentDefinition getActionDefinition(ServletRequest request) {
    210         return (ComponentDefinition) request.getAttribute(ACTION_DEFINITION);
    211     }
    212
    213     /**
    214      * Store definition in jsp context.
    215      * Mainly used by Struts to pass a definition defined in an Action to the forward.
    216      */
    217     public static void setActionDefinition(
    218         ServletRequest request,
    219         ComponentDefinition definition) {
    220
    221         request.setAttribute(ACTION_DEFINITION, definition);
    222     }
    223
    224     /**
    225      * Remove Definition stored in jsp context.
    226      * Mainly used by Struts to pass a definition defined in an Action to the forward.
    227      */
    228     public static void removeActionDefinition(
    229         ServletRequest request,
    230         ComponentDefinition definition) {
    231
    232         request.removeAttribute(ACTION_DEFINITION);
    233     }
    234
    235     /**
    236      * Populate Definition Factory Config from web.xml properties.
    237      * @param factoryConfig Definition Factory Config to populate.
    238      * @param servletConfig Current servlet config containing web.xml properties.
    239      * @exception IllegalAccessException if the caller does not have
    240      *  access to the property accessor method
    241      * @exception java.lang.reflect.InvocationTargetException if the property accessor method
    242      *  throws an exception
    243      * @see org.apache.commons.beanutils.BeanUtils
    244      * @since tiles 20020708
    245      */
    246     public static void populateDefinitionsFactoryConfig(
    247         DefinitionsFactoryConfig factoryConfig,
    248         ServletConfig servletConfig)
    249         throws IllegalAccessException, InvocationTargetException {
    250
    251         Map properties = new DefinitionsUtil.ServletPropertiesMap(servletConfig);
    252         factoryConfig.populate(properties);
    253     }
    254
    255     /**
    256      * Create FactoryConfig and initialize it from web.xml.
    257      *
    258      * @param servletConfig ServletConfig for the module with which
    259      *  this plug in is associated
    260      * @exception DefinitionsFactoryException if this <code>PlugIn</code> cannot
    261      *  be successfully initialized
    262      */
    263     protected static DefinitionsFactoryConfig readFactoryConfig(ServletConfig servletConfig)
    264         throws DefinitionsFactoryException {
    265
    266         // Create tiles definitions config object
    267         DefinitionsFactoryConfig factoryConfig = new DefinitionsFactoryConfig();
    268
    269         // Get init parameters from web.xml files
    270         try {
    271             DefinitionsUtil.populateDefinitionsFactoryConfig(
    272                 factoryConfig,
    273                 servletConfig);
    274
    275         } catch (Exception ex) {
    276             ex.printStackTrace();
    277             throw new DefinitionsFactoryException(
    278                 "Can't populate DefinitionsFactoryConfig class from 'web.xml'.",
    279                 ex);
    280         }
    281
    282         return factoryConfig;
    283     }
    284
    285     /**
    286      * Inner class.
    287      * Wrapper for ServletContext init parameters.
    288      * Object of this class is an hashmap containing parameters and values
    289      * defined in the servlet config file (web.xml).
    290      */
    291     static class ServletPropertiesMap extends HashMap {
    292         /**
    293          * Constructor.
    294          */
    295         ServletPropertiesMap(ServletConfig config) {
    296             // This implementation is very simple.
    297             // It is possible to avoid creation of a new structure, but this need
    298             // imply writing all Map interface.
    299             Enumeration e = config.getInitParameterNames();
    300             while (e.hasMoreElements()) {
    301                 String key = (String) e.nextElement();
    302                 put(key, config.getInitParameter(key));
    303             }
    304         }
    305     } // end inner class
    306
    307 }