View Javadoc

    1   //========================================================================
    2   //$Id: WrappedHandler.java,v 1.2 2005/11/11 22:55:39 gregwilkins Exp $
    3   //Copyright 2004-2006 Mort Bay Consulting Pty. Ltd.
    4   //------------------------------------------------------------------------
    5   //Licensed under the Apache License, Version 2.0 (the "License");
    6   //you may not use this file except in compliance with the License.
    7   //You may obtain a copy of the License at
    8   //http://www.apache.org/licenses/LICENSE-2.0
    9   //Unless required by applicable law or agreed to in writing, software
    10  //distributed under the License is distributed on an "AS IS" BASIS,
    11  //WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  //See the License for the specific language governing permissions and
    13  //limitations under the License.
    14  //========================================================================
    15
    16  package org.mortbay.jetty.handler;
    17
    18  import java.io.IOException;
    19
    20  import javax.servlet.ServletException;
    21  import javax.servlet.http.HttpServletRequest;
    22  import javax.servlet.http.HttpServletResponse;
    23
    24  import org.mortbay.component.LifeCycle;
    25  import org.mortbay.jetty.Handler;
    26  import org.mortbay.jetty.HandlerContainer;
    27  import org.mortbay.jetty.Server;
    28
    29  /* ------------------------------------------------------------ */
    30  /** A <code>HandlerWrapper</code> acts as a {@link Handler} but delegates the {@link Handler#handle handle} method and
    31   * {@link LifeCycle life cycle} events to a delegate. This is primarily used to implement the <i>Decorator</i> pattern.
    32   * @author gregw
    33   */
    34  public class HandlerWrapper extends AbstractHandlerContainer
    35  {
    36      private Handler _handler;
    37
    38      /* ------------------------------------------------------------ */
    39      /**
    40       *
    41       */
    42      public HandlerWrapper()
    43      {
    44          super();
    45      }
    46
    47      /* ------------------------------------------------------------ */
    48      /**
    49       * @return Returns the handlers.
    50       */
    51      public Handler getHandler()
    52      {
    53          return _handler;
    54      }
    55
    56      /* ------------------------------------------------------------ */
    57      /**
    58       * @param handler Set the {@link Handler} which should be wrapped.
    59       */
    60      public void setHandler(Handler handler)
    61      {
    62          try
    63          {
    64              Handler old_handler = _handler;
    65
    66              if (getServer()!=null)
    67                  getServer().getContainer().update(this, old_handler, handler, "handler");
    68
    69              if (handler!=null)
    70              {
    71                  handler.setServer(getServer());
    72              }
    73
    74              _handler = handler;
    75
    76              if (old_handler!=null)
    77              {
    78                  if (old_handler.isStarted())
    79                      old_handler.stop();
    80              }
    81          }
    82          catch(Exception e)
    83          {
    84              IllegalStateException ise= new IllegalStateException();
    85              ise.initCause(e);
    86              throw ise;
    87          }
    88      }
    89
    90      /* ------------------------------------------------------------ */
    91      /** Add a handler.
    92       * This implementation of addHandler calls setHandler with the
    93       * passed handler.  If this HandlerWrapper had a previous wrapped
    94       * handler, then it is passed to a call to addHandler on the passed
    95       * handler.  Thus this call can add a handler in a chain of
    96       * wrapped handlers.
    97       *
    98       * @param handler
    99       */
    100     public void addHandler(Handler handler)
    101     {
    102         Handler old = getHandler();
    103         if (old!=null && !(handler instanceof HandlerContainer))
    104             throw new IllegalArgumentException("Cannot add");
    105         setHandler(handler);
    106         if (old!=null)
    107             ((HandlerContainer)handler).addHandler(old);
    108     }
    109
    110
    111     public void removeHandler (Handler handler)
    112     {
    113         Handler old = getHandler();
    114         if (old!=null && (old instanceof HandlerContainer))
    115             ((HandlerContainer)old).removeHandler(handler);
    116         else if (old!=null && handler.equals(old))
    117             setHandler(null);
    118         else
    119             throw new IllegalStateException("Cannot remove");
    120     }
    121
    122
    123     /* ------------------------------------------------------------ */
    124     /*
    125      * @see org.mortbay.thread.AbstractLifeCycle#doStart()
    126      */
    127     protected void doStart() throws Exception
    128     {
    129         if (_handler!=null)
    130             _handler.start();
    131         super.doStart();
    132     }
    133
    134     /* ------------------------------------------------------------ */
    135     /*
    136      * @see org.mortbay.thread.AbstractLifeCycle#doStop()
    137      */
    138     protected void doStop() throws Exception
    139     {
    140         super.doStop();
    141         if (_handler!=null)
    142             _handler.stop();
    143     }
    144
    145     /* ------------------------------------------------------------ */
    146     /*
    147      * @see org.mortbay.jetty.EventHandler#handle(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
    148      */
    149     public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch) throws IOException, ServletException
    150     {
    151         if (_handler!=null && isStarted())
    152             _handler.handle(target,request, response, dispatch);
    153     }
    154
    155
    156     /* ------------------------------------------------------------ */
    157     public void setServer(Server server)
    158     {
    159         Server old_server=getServer();
    160
    161         super.setServer(server);
    162
    163         Handler h=getHandler();
    164         if (h!=null)
    165             h.setServer(server);
    166
    167         if (server!=null && server!=old_server)
    168             server.getContainer().update(this, null,_handler, "handler");
    169     }
    170
    171
    172     /* ------------------------------------------------------------ */
    173     protected Object expandChildren(Object list, Class byClass)
    174     {
    175         return expandHandler(_handler,list,byClass);
    176     }
    177
    178
    179 }