View Javadoc

    1   /*
    2    * $Id: ComponentDefinitionsFactoryWrapper.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.definition;
    23
    24  import java.util.HashMap;
    25  import java.util.Map;
    26
    27  import javax.servlet.ServletContext;
    28  import javax.servlet.ServletRequest;
    29
    30  import org.apache.struts.tiles.ComponentDefinition;
    31  import org.apache.struts.tiles.ComponentDefinitionsFactory;
    32  import org.apache.struts.tiles.DefinitionsFactory;
    33  import org.apache.struts.tiles.DefinitionsFactoryConfig;
    34  import org.apache.struts.tiles.DefinitionsFactoryException;
    35  import org.apache.struts.tiles.NoSuchDefinitionException;
    36  import org.apache.struts.util.RequestUtils;
    37
    38  /**
    39   * Wrapper from new definition factory interface to old interface.
    40   * This class provides mapping from the old interface's life cycle to the new life cycle.
    41   * @since 20020708
    42   */
    43  public class ComponentDefinitionsFactoryWrapper implements DefinitionsFactory {
    44
    45      /**
    46       * The underlying factory.
    47       */
    48      private ComponentDefinitionsFactory factory = null;
    49
    50      /**
    51       * Factory configuration,
    52       */
    53      private DefinitionsFactoryConfig config = null;
    54
    55      /**
    56       * Constructor.
    57       * Create new wrapper for specified factory.
    58       * @param factory The factory to create a wrapper for.
    59       */
    60      public ComponentDefinitionsFactoryWrapper(ComponentDefinitionsFactory factory) {
    61          this.factory = factory;
    62      }
    63
    64      /**
    65       * Constructor.
    66       * Create new wrapper.
    67       * The config object passed to init method should reference a factory implementing
    68       * {@link ComponentDefinitionsFactory}.
    69       */
    70      public ComponentDefinitionsFactoryWrapper() {
    71          super();
    72      }
    73
    74      /**
    75       * Get requested definition.
    76       * @param name Name of the definition.
    77       * @param request The request we are processing.
    78       * @param servletContext Our servlet context.
    79       * @return ComponentDefition
    80       */
    81      public ComponentDefinition getDefinition(
    82          String name,
    83          ServletRequest request,
    84          ServletContext servletContext)
    85          throws NoSuchDefinitionException, DefinitionsFactoryException {
    86
    87          return factory.getDefinition(name, request, servletContext);
    88      }
    89
    90      /**
    91       * Call underlying factory init method.
    92       * @param config DefinitionsFactoryConfig.
    93       * @param servletContext Our servlet context.
    94       */
    95      public void init(DefinitionsFactoryConfig config, ServletContext servletContext)
    96          throws DefinitionsFactoryException {
    97
    98          this.config = config;
    99
    100         // create factory and initialize it
    101         if (factory == null) {
    102             factory = createFactoryInstance(config.getFactoryClassname());
    103         }
    104
    105         factory.initFactory(servletContext, createConfigMap(config));
    106     }
    107
    108     /**
    109      * Do nothing because old life cycle has no equivalent.
    110      */
    111     public void destroy() {
    112         factory = null;
    113     }
    114
    115     /**
    116      * Set underlying factory configuration.
    117      * @param config DefinitionsFactoryConfig to use.
    118      * @param servletContext Our servlet context.
    119      *
    120      */
    121     public void setConfig(
    122         DefinitionsFactoryConfig config,
    123         ServletContext servletContext)
    124         throws DefinitionsFactoryException {
    125
    126         ComponentDefinitionsFactory newFactory =
    127             createFactoryInstance(config.getFactoryClassname());
    128
    129         newFactory.initFactory(servletContext, createConfigMap(config));
    130         factory = newFactory;
    131     }
    132
    133     /**
    134      * Get underlying factory configuration.
    135      * @return DefinitionsFactoryConfig.
    136      */
    137     public DefinitionsFactoryConfig getConfig() {
    138         return config;
    139     }
    140
    141     /**
    142      * Get internal factory.
    143      * @return The internal ComponentDefitionsFactory.
    144      */
    145     public ComponentDefinitionsFactory getInternalFactory() {
    146         return factory;
    147     }
    148
    149     /**
    150      * Create Definition factory from provided classname which must implement {@link ComponentDefinitionsFactory}.
    151      * Factory class must extend {@link DefinitionsFactory}.
    152      * @param classname Class name of the factory to create.
    153      * @return newly created factory.
    154      * @throws DefinitionsFactoryException If an error occur while initializing factory
    155      */
    156     protected ComponentDefinitionsFactory createFactoryInstance(String classname)
    157         throws DefinitionsFactoryException {
    158
    159         try {
    160             Class factoryClass = RequestUtils.applicationClass(classname);
    161             Object factory = factoryClass.newInstance();
    162             return (ComponentDefinitionsFactory) factory;
    163
    164         } catch (ClassCastException ex) { // Bad classname
    165             throw new DefinitionsFactoryException(
    166                 "Error - createDefinitionsFactory : Factory class '"
    167                     + classname
    168                     + " must implement 'DefinitionsFactory'.",
    169                 ex);
    170
    171         } catch (ClassNotFoundException ex) { // Bad classname
    172             throw new DefinitionsFactoryException(
    173                 "Error - createDefinitionsFactory : Bad class name '"
    174                     + classname
    175                     + "'.",
    176                 ex);
    177
    178         } catch (InstantiationException ex) { // Bad constructor or error
    179             throw new DefinitionsFactoryException(ex);
    180
    181         } catch (IllegalAccessException ex) {
    182             throw new DefinitionsFactoryException(ex);
    183         }
    184
    185     }
    186
    187     /**
    188      * Return String representation.
    189      * Calls toString() on underlying factory.
    190      * @return String representation.
    191      */
    192     public String toString() {
    193         return getInternalFactory().toString();
    194     }
    195
    196     /**
    197      * Create map of configuration attributes from configuration object.
    198      * Mapping is done between old names and new names.
    199      * @param config The DefinitionsFactoryConfig to use.
    200      * @return Map Map of name/value pairs.
    201      */
    202     public static Map createConfigMap(DefinitionsFactoryConfig config) {
    203         Map map = new HashMap(config.getAttributes());
    204         // Add property attributes using old names
    205         map.put(
    206             DefinitionsFactoryConfig.DEFINITIONS_CONFIG_PARAMETER_NAME,
    207             config.getDefinitionConfigFiles());
    208
    209         map.put(
    210             DefinitionsFactoryConfig.PARSER_VALIDATE_PARAMETER_NAME,
    211             (config.getParserValidate() ? Boolean.TRUE.toString() : Boolean.FALSE.toString()));
    212
    213         if (!"org.apache.struts.tiles.xmlDefinition.I18nFactorySet"
    214             .equals(config.getFactoryClassname())) {
    215
    216             map.put(
    217                 DefinitionsFactoryConfig.FACTORY_CLASSNAME_PARAMETER_NAME,
    218                 config.getFactoryClassname());
    219         }
    220
    221         return map;
    222     }
    223
    224 }