View Javadoc

    1   package org.apache.turbine.util.velocity;
    2
    3
    4   /*
    5    * Licensed to the Apache Software Foundation (ASF) under one
    6    * or more contributor license agreements.  See the NOTICE file
    7    * distributed with this work for additional information
    8    * regarding copyright ownership.  The ASF licenses this file
    9    * to you under the Apache License, Version 2.0 (the
    10   * "License"); you may not use this file except in compliance
    11   * with the License.  You may obtain a copy of the License at
    12   *
    13   *   http://www.apache.org/licenses/LICENSE-2.0
    14   *
    15   * Unless required by applicable law or agreed to in writing,
    16   * software distributed under the License is distributed on an
    17   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    18   * KIND, either express or implied.  See the License for the
    19   * specific language governing permissions and limitations
    20   * under the License.
    21   */
    22
    23
    24  import java.lang.reflect.InvocationTargetException;
    25  import java.lang.reflect.Method;
    26  import java.util.Iterator;
    27
    28  import org.apache.fulcrum.parser.ParameterParser;
    29  import org.apache.turbine.modules.ActionEvent;
    30  import org.apache.turbine.pipeline.PipelineData;
    31  import org.apache.turbine.services.velocity.TurbineVelocity;
    32  import org.apache.turbine.util.RunData;
    33  import org.apache.velocity.context.Context;
    34
    35  /**
    36   * If you are using VelocitySite stuff, then your Action's should
    37   * extend this class instead of extending the ActionEvent class.  The
    38   * difference between this class and the ActionEvent class is that
    39   * this class will first attempt to execute one of your doMethod's
    40   * with a constructor like this:
    41   *
    42   * <p><code>doEvent(RunData data, Context context)</code></p>
    43   *
    44   * <p>It gets the context from the TemplateInfo.getTemplateContext()
    45   * method. If it can't find a method like that, then it will try to
    46   * execute the method without the Context in it.</p>
    47   *
    48   * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
    49   * @author <a href="mailto:jvanzyl@periapt.com">Jason van Zyl</a>
    50   * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
    51   * @author <a href="mailto:peter@courcoux.biz">Peter Courcoux</a>
    52   * @version $Id: VelocityActionEvent.java 1073174 2011-02-21 22:18:45Z tv $
    53   */
    54  public abstract class VelocityActionEvent extends ActionEvent
    55  {
    56      /** Constant needed for Reflection */
    57      private static final Class [] methodParams
    58              = new Class [] { RunData.class, Context.class };
    59
    60      /** Indicates whether or not this module has been initialized. */
    61      protected boolean initialized = false;
    62
    63      /**
    64       * You need to implement this in your classes that extend this
    65       * class.
    66       *
    67       * @deprecated Use PipelineData version instead.
    68       * @param data A Turbine RunData object.
    69       * @exception Exception a generic exception.
    70       */
    71      @Deprecated
    72      @Override
    73      public abstract void doPerform(RunData data)
    74              throws Exception;
    75
    76  	/**
    77  	 * You need to implement this in your classes that extend this class.
    78  	 * Should revert to abstract once RunData is gone.
    79  	 * @param data Turbine information.
    80  	 * @exception Exception a generic exception.
    81  	 */
    82  	@Override
    83      public void doPerform(PipelineData pipelineData)
    84  			throws Exception
    85  	{
    86  	      RunData data = getRunData(pipelineData);
    87  	      doPerform(data);
    88  	}
    89      /**
    90       * Provides a means of initializing the module.
    91       *
    92       * @throws Exception a generic exception.
    93       */
    94      protected abstract void initialize()
    95          throws Exception;
    96
    97      /**
    98       * This overrides the default Action.perform() to execute the
    99       * doEvent() method.  If that fails, then it will execute the
    100      * doPerform() method instead.
    101      *
    102      * @deprecated Use PipelineData version instead.
    103      * @param data A Turbine RunData object.
    104      * @exception Exception a generic exception.
    105      */
    106     @Deprecated
    107     @Override
    108     protected void perform(RunData data)
    109             throws Exception
    110     {
    111         try
    112         {
    113             if (!initialized)
    114             {
    115                 initialize();
    116             }
    117             executeEvents(data, TurbineVelocity.getContext(data));
    118         }
    119         catch (NoSuchMethodException e)
    120         {
    121             doPerform(data);
    122         }
    123     }
    124
    125     /**
    126      * This overrides the default Action.perform() to execute the
    127      * doEvent() method.  If that fails, then it will execute the
    128      * doPerform() method instead.
    129      *
    130      * @param data A Turbine RunData object.
    131      * @exception Exception a generic exception.
    132      */
    133     @Override
    134     protected void perform(PipelineData pipelineData)
    135             throws Exception
    136     {
    137         try
    138         {
    139             if (!initialized)
    140             {
    141                 initialize();
    142             }
    143
    144             executeEvents(pipelineData, TurbineVelocity.getContext(pipelineData));
    145         }
    146         catch (NoSuchMethodException e)
    147         {
    148             doPerform(pipelineData);
    149         }
    150     }
    151     /**
    152      * This method should be called to execute the event based system.
    153      * @deprecated Use PipelineData version instead.
    154      * @param data A Turbine RunData object.
    155      * @param context Velocity context information.
    156      * @exception Exception a generic exception.
    157      */
    158     @Deprecated
    159     public void executeEvents(RunData data, Context context)
    160             throws Exception
    161     {
    162         // Name of the button.
    163         String theButton = null;
    164
    165         // ParameterParser.
    166         ParameterParser pp = data.getParameters();
    167
    168         String button = pp.convert(BUTTON);
    169         String key = null;
    170
    171         // Loop through and find the button.
    172         for (Iterator it = pp.keySet().iterator(); it.hasNext();)
    173         {
    174             key = (String) it.next();
    175             if (key.startsWith(button))
    176             {
    177                 if (considerKey(key, pp))
    178                 {
    179                     theButton = formatString(key, pp);
    180                     break;
    181                 }
    182             }
    183         }
    184
    185         if (theButton == null)
    186         {
    187             throw new NoSuchMethodException(
    188                     "ActionEvent: The button was null");
    189         }
    190
    191         Method method = null;
    192         try
    193         {
    194             method = getClass().getMethod(theButton, methodParams);
    195             Object[] methodArgs = new Object[] { data, context };
    196
    197             if (log.isDebugEnabled())
    198             {
    199                 log.debug("Invoking " + method);
    200             }
    201
    202             method.invoke(this, methodArgs);
    203         }
    204         catch (NoSuchMethodException nsme)
    205         {
    206             // Attempt to execute things the old way..
    207             if (log.isDebugEnabled())
    208             {
    209                 log.debug("Couldn't locate the Event ( " + theButton
    210                         + "), running executeEvents() in "
    211                         + super.getClass().getName());
    212             }
    213
    214             super.executeEvents(data);
    215         }
    216         catch (InvocationTargetException ite)
    217         {
    218             Throwable t = ite.getTargetException();
    219             log.error("Invokation of " + method , t);
    220             throw ite;
    221         }
    222         finally
    223         {
    224             pp.remove(key);
    225         }
    226     }
    227
    228     /**
    229      * This method should be called to execute the event based system.
    230      *
    231      * @param data A Turbine RunData object.
    232      * @param context Velocity context information.
    233      * @exception Exception a generic exception.
    234      */
    235     public void executeEvents(PipelineData pipelineData, Context context)
    236             throws Exception
    237     {
    238 	    RunData data = getRunData(pipelineData);
    239         // Name of the button.
    240         String theButton = null;
    241
    242         // ParameterParser.
    243         ParameterParser pp = data.getParameters();
    244
    245         String button = pp.convert(BUTTON);
    246         String key = null;
    247
    248         // Loop through and find the button.
    249         for (Iterator it = pp.keySet().iterator(); it.hasNext();)
    250         {
    251             key = (String) it.next();
    252             if (key.startsWith(button))
    253             {
    254                 if (considerKey(key, pp))
    255                 {
    256                     theButton = formatString(key, pp);
    257                     break;
    258                 }
    259             }
    260         }
    261
    262         if (theButton == null)
    263         {
    264             throw new NoSuchMethodException(
    265                     "ActionEvent: The button was null");
    266         }
    267
    268         Method method = null;
    269         try
    270         {
    271             method = getClass().getMethod(theButton, methodParams);
    272             Object[] methodArgs = new Object[] { pipelineData, context };
    273
    274             if (log.isDebugEnabled())
    275             {
    276                 log.debug("Invoking " + method);
    277             }
    278
    279             method.invoke(this, methodArgs);
    280         }
    281         catch (NoSuchMethodException nsme)
    282         {
    283             // Attempt to execute things the old way..
    284             if (log.isDebugEnabled())
    285             {
    286                 log.debug("Couldn't locate the Event ( " + theButton
    287                         + "), running executeEvents() in "
    288                         + super.getClass().getName());
    289             }
    290
    291             super.executeEvents(pipelineData);
    292         }
    293         catch (InvocationTargetException ite)
    294         {
    295             Throwable t = ite.getTargetException();
    296             log.error("Invokation of " + method , t);
    297             throw ite;
    298         }
    299         finally
    300         {
    301             pp.remove(key);
    302         }
    303     }
    304
    305 }