001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
003 * agreements. See the NOTICE file distributed with this work for additional information regarding
004 * copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the
005 * "License"); you may not use this file except in compliance with the License. You may obtain a
006 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable
007 * law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
008 * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
009 * for the specific language governing permissions and limitations under the License.
010 */
011 package javax.portlet.faces;
012
013 import javax.portlet.ActionRequest;
014 import javax.portlet.ActionResponse;
015 import javax.portlet.EventRequest;
016 import javax.portlet.EventResponse;
017 import javax.portlet.PortletConfig;
018 import javax.portlet.PortletException;
019 import javax.portlet.RenderRequest;
020 import javax.portlet.RenderResponse;
021 import javax.portlet.ResourceRequest;
022 import javax.portlet.ResourceResponse;
023 import javax.portlet.UnavailableException;
024
025 /**
026 * The <CODE>Bridge</CODE> interface is used by a portlet to execute a JSF artifact. Its lifecycle
027 * follows the pattern used by other web components such as portlets or servlets, namely:
028 * <ul>
029 * <li><code>init</code>: one time (per portlet) initialization. Usually invoked during portlet
030 * <code>init</code> but may also occur lazily. Context is passed to the Bridge at initialization
031 * via <code>PortletContext</code> attributes. See method description for details. </li>
032 * <li><code>doFacesRequest</code>: called for each portlet request that is to be handled by
033 * Faces. Must only be called after the bridge has been initialized. </li>
034 * <li><code>destroy</code>: called to destroy this bridge instance. Usually invoked during
035 * portlet <code>destroy</code> but may also occur earlier if the portlet decides to reclaim
036 * resources. </li>
037 * </ul>
038 * <P>
039 * Portlet developers are encouraged to allow deployers an ability to configure the particular
040 * Bridge implementation it uses within a given deployment. This ensures a best fit solution for a
041 * given application server, portlet container, and/or Faces environment. The specifics for this
042 * configuation are undefined. Each portlet can define a preferred mechanism. Subclasses of
043 * {@link GenericFacesPortlet} automatically inherit this behavior as it recognizes a defined
044 * portlet initialization parameter.
045 * <p>
046 * Implementations of this <code>Bridge</code> interface are required to have a <code>code</code>
047 * constructor.
048 */
049 public interface
050
051 Bridge
052 {
053
054 // Base Bridge attribute/context parameter prefix
055 public static final String BRIDGE_PACKAGE_PREFIX = "javax.portlet.faces.";
056
057 // Following are the names of context init parameters that control
058 // Bridge behavior. These are specified in the web.xml
059
060 /**
061 * Context initialization parameter that specifies the maximum number of bridge
062 * request scopes to preserved across all uses within this application.
063 */
064 public static final String MAX_MANAGED_REQUEST_SCOPES =
065 BRIDGE_PACKAGE_PREFIX + "MAX_MANAGED_REQUEST_SCOPES";
066
067 /**
068 * Context initialization parameter that defines the policy the bridge uses for
069 * rendering. Parameter value is the string representaiton of one of the
070 * BridgeRenderPolicy enum values.
071 */
072 public static final String RENDER_POLICY = BRIDGE_PACKAGE_PREFIX + "RENDER_POLICY";
073
074 /**
075 * Context initialization parameter that defines the lifecycle ID used to
076 * identify the Faces Lifecycle used for this application.
077 */
078 public static final String LIFECYCLE_ID = "javax.faces.LIFECYCLE_ID";
079
080 /**
081 * Context initialization parameter that defines the SAVESTATE_FIELD_MARKER
082 * in use in the given deployment. If not set, consult your bridge implementation
083 * documentation to determine which Faces implementations it automatically
084 * detects and supports. For example the bridge RI will detect and run
085 * properly in either the Faces RI or MyFaces environments without this being set.
086 */
087 public static final String SAVESTATE_FIELD_MARKER =
088 BRIDGE_PACKAGE_PREFIX + "SAVESTATE_FIELD_MARKER";
089
090 // Following are the names of context init attributes set by the portlet to control
091 // Bridge behavior. For the GenericFacesPortlet, the values for these come from
092 // portlet initialization parameters in the portlet.xml
093
094 /** A PortletContext attribute that a portlet can set prior
095 * to calling the bridge's init() method to configure the bridge to exclude
096 * specific attributes from its bridge request scope. Value is a comma delimited
097 * list containing either a fully qualified attribute name or package name terminated
098 * with a ".*" wildcard indicator. In this later case, all attributes in the package
099 * name which precedes the ".*" are excluded, non recursive.<br>
100 *
101 * As this attribute is scoped to a specific portlet in an application-wide context
102 * the attribute name must be include the portlet name as follows:
103 * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + excludedRequestAttributes
104 */
105 public static final String EXCLUDED_REQUEST_ATTRIBUTES = "excludedRequestAttributes";
106
107 /** PortletContext attribute that a portlet must set prior
108 * to calling the bridge's init() method to convey to the bridge the set of default
109 * viewIds that correspond to this portlet's supported <code>PortletMode</code>s.
110 * Its value is a Map with one entry per mode. The mode name is the key. The entry's
111 * value is the corresponding default viewId the bridge should use for this mode.
112 * <br>
113 *
114 * As this attribute is scoped to a specific portlet in an application-wide context
115 * the attribute name must be include the portlet name as follows:
116 * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + DEFAULT_VIEWID_MAP
117 */
118 public static final String DEFAULT_VIEWID_MAP = "defaultViewIdMap";
119
120
121 /** A PortletContext attribute that a portlet can set prior
122 * to calling the bridge's init() method to configure the bridge to preserve
123 * action parameters received by this portlet along with bridge's request scope so
124 * that they may be restored and acessed in subsequent renders. If "true", the
125 * action parameters are preserved. If "false", they are not preserved. The bridge
126 * default is "false".<br>
127 *
128 * As this attribute is scoped to a specific portlet in an application-wide context
129 * the attribute name must be include the portlet name as follows:
130 * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + preserveActionParams
131 */
132 public static final String PRESERVE_ACTION_PARAMS = "preserveActionParams";
133
134 /** A PortletContext attribute that a portlet can set prior
135 * to calling the bridge's init() method to configure the bridge to use/call
136 * the associated eventHandler when processing an event. Value is an instance of
137 * <code>BridgeEventHandler</code>.
138 *
139 * As this attribute is scoped to a specific portlet in an application-wide context
140 * the attribute name must be include the portlet name as follows:
141 * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + bridgeEventHandler
142 */
143 public static final String BRIDGE_EVENT_HANDLER = "bridgeEventHandler";
144
145 /** A PortletContext attribute that a portlet can set prior
146 * to calling the bridge's init() method to configure the bridge to use/call
147 * the associated publicRenderParameterHandler. This handler is used to
148 * process updates that result from public render parameter changes passed in
149 * a request. The bridge first pushs all the public render parameter values into the models and
150 * then calls this handler's processUpdates method. The handler can then compute
151 * further model changes based on the changes. Value is an instance of
152 * <code>BridgePublicRenderParameterHandler</code>.
153 *
154 * As this attribute is scoped to a specific portlet in an application-wide context
155 * the attribute name must be include the portlet name as follows:
156 * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + bridgeEventHandler
157 */
158 public static final String BRIDGE_PUBLIC_RENDER_PARAMETER_HANDLER = "bridgePublicRenderParameterHandler";
159
160
161 /** A PortletContext attribute that a portlet can set prior
162 * to calling the bridge's init() method to configure the bridge to default
163 * the renderKitId used for rendering this portlet to the named Id. In Faces, the
164 * default renderKitId is set in the faces-config.xml and is application wide. In 1.2
165 * this can be overidden by a specially named request parameter. To allow differing portlets
166 * in the same app to use different default render kits, without having to add this
167 * parameter, the portlet can set this attribute prior to the bridge init(). The bridge
168 * will recognize this configuration value and on each request add the special faces
169 * request parameter to the request (if its not already present).
170 */
171 public static final String DEFAULT_RENDERKIT_ID = "defaultRenderKitId";
172
173
174 // The following are request attributes a portlet can set to control the request
175 // processing of the bridge.
176
177 /** PortletRequest attribute that a portlet may set prior
178 * to calling the bridge's doFacesRequest() method. The value of this
179 * attribute is a <code>String</code> representing the Faces viewId the
180 * bridge is to target for this request. Used by a portlet to specifically
181 * control a request's view target in situations such as navigating from
182 * a nonFaces view to a specific Faces view (other than the default).<p>
183 * Generally, the use of this attribute is mutually exclusive with the use
184 * of VIEW_PATH. If both have been set in a given request, the bridge gives
185 * precedence to VIEW_ID.
186 */
187 public static final String VIEW_ID = BRIDGE_PACKAGE_PREFIX + "viewId";
188
189 /** PortletRequest attribute that a portlet may set prior
190 * to calling the bridge's doFacesRequest() method. The value of this
191 * attribute is a <code>String</code> containing a <code>ContextPath</code>
192 * relative path in which the Faces viewId is encoded. Like VIEW_ID, this
193 * attribute provides a means for a portlet to explicitly control the Faces
194 * target for a specific request. It is used in situations such as navigating from
195 * a nonFaces view to a specific Faces view (other than the default).<p>
196 * Generally, the use of this attribute is mutually exclusive with the use
197 * of VIEW_PATH. If both have been set in a given request, the bridge gives
198 * precedence to VIEW_ID.
199 */
200 public static final String VIEW_PATH = BRIDGE_PACKAGE_PREFIX + "viewPath";
201
202 // Names for special QueryString parameters names the Bridge recognizes in
203 // encodeActionURL as signifying to change the corresponding portlet values
204 // in the resulting URL
205
206 /**
207 * Special token parameter in the url passed to the bridge's ExternalContext.encodeActionURL()
208 * that it recognizes as an indication that this action should encode a PortletMode
209 * change to the one indicated by the parameter's value.
210 */
211 public static final String PORTLET_MODE_PARAMETER = BRIDGE_PACKAGE_PREFIX + "PortletMode";
212
213 /**
214 * Special token parameter in the url passed to the bridge's ExternalContext.encodeActionURL()
215 * that it recognizes as an indication that this action should encode a WindowState change to
216 * the one indicated by the parameter's value.
217 */
218 public static final String PORTLET_WINDOWSTATE_PARAMETER = BRIDGE_PACKAGE_PREFIX + "WindowState";
219
220 /**
221 * Special token parameter in the url passed to the bridge's ExternalContext.encodeActionURL()
222 * that it recognizes as an indication that this action should encode a security level change to
223 * the one indicated by the parameter's value.
224 */
225 public static final String PORTLET_SECURE_PARAMETER = BRIDGE_PACKAGE_PREFIX + "Secure";
226
227 /**
228 * Special token parameter in the url passed to the bridge's ExternalContext.encodeActionURL()
229 * that it recognizes as an indication that this action should be treated as a direct link
230 * and hence shouldn't be encoded as a Portlet action. Rather encodeActionURL merely returns
231 * this url unchanged.
232 */
233 public static final String DIRECT_LINK = BRIDGE_PACKAGE_PREFIX + "DirectLink";
234
235 /**
236 * Special token parameter in the url passed to the bridge's ExternalContext.encodeResourceURL()
237 * that it recognizes as an indication that this resource should be handled in protocol.
238 */
239 public static final String IN_PROTOCOL_RESOURCE_LINK =
240 BRIDGE_PACKAGE_PREFIX + "InProtocolResourceLink";
241
242 /**
243 * Special token parameter in the url passed to the bridge's ExternalContext.encodeResourceURL()
244 * that it recognizes as an indication that an URL refering back to the page which
245 * contains this portlet should be encoded in the resource url. This reference is
246 * encoded as the value of a query string parameter whose name is the value of this back
247 * link token parameter.
248 */
249 public static final String BACK_LINK = BRIDGE_PACKAGE_PREFIX + "BackLink";
250
251 /**
252 * Special token parameter in the url passed to the bridge's ExternalContext.encodeResourceURL()
253 * that it recognizes as an indication that this url refers to Faces view (navigation) and
254 * hence should be encoded as an portlet ActionURL rather then a portlet resource url. This token
255 * is intended for use in urls signifying a view navigation using components such as
256 * <code>h:outputLink</code>.
257 */
258 public static final String VIEW_LINK = BRIDGE_PACKAGE_PREFIX + "ViewLink";
259
260
261 // Request attributes set by the bridge that can be used by Faces extensions
262 // and/or applications to properly run in a portlet environment.
263
264 /**
265 * A PortletRequest attribute set by the bridge when processing a Faces request
266 * that signals this request is a Faces postback. Its provided as
267 * an alternative signal to the common reliance on the view state parameter as
268 * an indicator that this is a postback request. Implementations needing this
269 * information and not using the view state parameter indicator can check this
270 * attribute when running in a portlet environment.
271 */
272 public static final String IS_POSTBACK_ATTRIBUTE = BRIDGE_PACKAGE_PREFIX + "isPostback";
273
274 /** A PortletRequest attribute set by the bridge in its
275 * <code>ViewHandler.renderView</code> prior to dispatching the request
276 * to the view (jsp)to indicating a filter should
277 * put the AFTER_VIEW_CONTENT in a buffer on the request for it to process after
278 * rendering the view components. In conjunction with the filter this enables
279 * preserving rendering order of native JSP rendering and Faces rendering in a jsp.
280 */
281 public static final String RENDER_CONTENT_AFTER_VIEW =
282 BRIDGE_PACKAGE_PREFIX + "RenderContentAfterView";
283
284 /** A PortletRequest attribute set by an include filter in recognition of the
285 * RenderContentAfterView bridge attribute. Its value is either char[] or byte[]
286 * holding the AFTER_VIEW_CONTENT generated while rendering this jsp.
287 * In conjunction with the bridge this enables
288 * preserving rendering order of native JSP rendering and Faces rendering in a jsp.
289 */
290 public static final String AFTER_VIEW_CONTENT = BRIDGE_PACKAGE_PREFIX + "AfterViewContent";
291
292 /** PortletRequest attribute set by the bridge prior to creating/acquiring a
293 * <code>FacesContext</code>. Its value indicates which portlet phase this
294 * Faces is executing in. It can be used by Faces subsystems not only to determine
295 * the portlet exectution phase but if present (not null) as an indication the request
296 * is being processed in a portlet container.
297 */
298 public static final String PORTLET_LIFECYCLE_PHASE = BRIDGE_PACKAGE_PREFIX + "phase";
299
300 /** PortletSession attribute set by the bridge to hold the last viewId accessed in a given mode.
301 * The attribute (key) is composed of this name + the mode name. I.e.
302 * javax.portlet.faces.viewIdHistory.view. There is one attribute per supported portlet
303 * mode. The attributes are always set even if the user session has never entered the
304 * mode. Its initial setting/value is determined by the default viewId configured
305 * for the mode. Attribute is used by developers to reference/return to the last view in
306 * a given Mode from another mode.
307 */
308 public static final String VIEWID_HISTORY = BRIDGE_PACKAGE_PREFIX + "viewIdHistory";
309
310
311 /** Name of PortletResponse property set by the bridge when it recognizes that the
312 * view has been rendered using a <code>NamingContainer</code> that ensures all
313 * generated ids are namespaced using the consumer provided unique portlet id.
314 */
315 public static final String PORTLET_NAMESPACED_RESPONSE_PROPERTY =
316 "X-JAVAX-PORTLET-FACES-NAMESPACED-RESPONSE";
317
318 /** Name of the render parameter set by the bridge when it encodes a navigation
319 * link to a nonFaces target. Though the bridge recognizes nonFaces targets when
320 * it encodes a navigational link, it does not handle the subsequent request.
321 * It only handles requests for Faces targets. It is the portlet's responsibility
322 * to detect and handle these requests. When the nonFaces target is a path based
323 * resource (such as a jsp or servlet), the <code>ContextPath</code> relative path
324 * of the resource is written as the value of this render parameter. For convenience,
325 * the GenericFacesPortlet recognizes this render parameter in received requests
326 * and uses the <code>PortletRequestDispatcher</code> to dispatch to the encoded
327 * path instead of calling the bridge to execute the request.
328 */
329 public static final String NONFACES_TARGET_PATH_PARAMETER = "_jsfBridgeNonFacesView";
330
331 /** Name of a request parameter (generally) encoded in a link from a nonFaces
332 * view response. It acts as a marker to the portlet that the nonFaces view
333 * intends to navigate to the Faces view expressed in the value of this parameter.
334 * It differs from the <code>FACES_VIEW_PATH_PARAMETER</code> in that its value
335 * is the actual Faces viewId of the target while the formaer is a
336 * <code>ContextPath</code> relative path containing the viewId.<p>
337 * Portlets receiving such a parameter should set the the corresponding request
338 * attribute <code>javax.portlet.faces.viewId</code> before calling the bridge
339 * to handle the request.
340 */
341 public static final String FACES_VIEW_ID_PARAMETER = "_jsfBridgeViewId";
342
343 /** Name of a request parameter (generally) encoded in a link from a nonFaces
344 * view response. It acts as a marker to the portlet that the nonFaces view
345 * intends to navigate to the Faces view expressed in the value of this parameter.
346 * It differs from the <code>FACES_VIEW_ID_PARAMETER</code> in that its value
347 * is a <code>ContextPath</code> relative path containing the viewId while the former
348 * is the viewId itself.<p>
349 * Portlets receiving such a parameter should set the the corresponding request
350 * attribute <code>javax.portlet.faces.viewPath</code> before calling the bridge
351 * to handle the request.
352 */
353 public static final String FACES_VIEW_PATH_PARAMETER = "_jsfBridgeViewPath";
354
355
356
357 /** Special value recognized during <code>encodeActionURL</code> of a portlet: url containing either
358 * the <code>_jsfBridgeViewId</code> or <code>_jsfBridgeViewPath</code> parameter.
359 * <code>encodeActionURL</code> recognizes this value as indicating it needs to generate and
360 * encode an URL to the current JSF including its current state. I.e. It not only
361 * encodes the link reference but also the existing render parameters so they can be carried forward
362 * to reestablish the state.
363 */
364 public static final String FACES_USE_CURRENT_VIEW_PARAMETER = "_jsfBridgeCurrentView";
365
366 /** Enumeration whose values describe the current portlet phase the bridge
367 * is executing Faces within.
368 */
369 public static enum PortletPhase
370 {
371 ACTION_PHASE,
372 RENDER_PHASE,
373 EVENT_PHASE,
374 RESOURCE_PHASE,
375 ;
376 }
377
378 /** Enumeration whose values describe the render policy used by the bridge
379 * to render portlets in this application. A policy of DEFAULT indicates
380 * the bridge will first delegate rendering and if this results in an
381 * exception being thrown will render the itself. A policy of ALWAYS_DELEGATE
382 * indicates the bridge will always delegate rendering, never rendering itself.
383 * A policy of NEVER_DELEGATE indicates the bridge will always render itself without
384 * delegating.
385 */
386 public static enum BridgeRenderPolicy
387 {
388 DEFAULT,
389 ALWAYS_DELEGATE,
390 NEVER_DELEGATE,
391 ;
392 }
393
394 /**
395 * Called by the portlet. It indicates that the bridge is being placed into service.
396 * <p>
397 * The portlet calls the <code>init</code> method exactly once before invoking other lifecycle
398 * methods. Usually, done immediately after instantiating the bridge. The <code>init</code>
399 * method must complete successfully before the bridge can receive any requests.
400 * <p>
401 * The portlet cannot place the bridge into service if the <code>init</code> method Throws a
402 * <code>BridgeException</code>.
403 * <p>
404 * Initialization context is passed to bridge via <code>PortletContext</code> attributes. The
405 * following attributes are defined:
406 * <ul>
407 * <li><code>javax.portlet.faces.encodeRedirectURL</code>: instructs the bridge to call
408 * <code>ExternalContext.encodeActionURL()</code> before processing the redirect request. This
409 * exists because some (newer) versions of JSF 1.2 call <code>encodeActionURL</code> before
410 * calling <code>redirect</code> while others do not. This flag adjusts the behavior of the
411 * bridge in accordance with the JSF 1.2 implementation it runs with.
412 * <li><code>javax.portlet.faces.numManagedActionScopes</code>: defines the maximum number of
413 * actionScopes this bridge preserves at any given time. Value is an integer. ActionScopes are
414 * managed on a per Bridge class portlet context wide basis. As a typical portlet application uses
415 * the same bridge implementation for all its Faces based portlets, this means that all
416 * actionScopes are managed in a single bucket.<br>
417 * For convenience this interface defines the <code>NUM_MANAGED_ACTIONSCOPES</code> constant.
418 * <li><code>javax.faces.lifecycleID</code>: defines the Faces <code>Lifecycle</code> id
419 * that bridge uses when acquiring the <code>Faces.Lifecycle</code> via which it executes the
420 * request. As a context wide attribute, all bridge instances in this portlet application will use
421 * this lifecyle.
422 * <li><code>javax.portlet.faces.[portlet name].preserveActionParams</code>: instructs the
423 * bridge to preserve action parameters in the action scope and represent them in subsequent
424 * renders. Should be used only when binding to a Faces implementation that relies on accessing
425 * such parameters during its render phase. As this is a portlet/bridge instance specific
426 * attribute, the <code>PortletContext</code>attribute name is qualified by the portlet
427 * instance name. This allows different portlets within the same portlet application to have
428 * different settings.<br>
429 * For convenience this interfaces defines a number of constants that simplifies constructing
430 * and/or recognizing this name.
431 * </ul>
432 *
433 * @param config
434 * a <code>PortletConfig</code> object containing the portlet's configuration and
435 * initialization parameters
436 * @exception BridgeException
437 * if an exception has occurred that interferes with the bridge's normal operation.
438 * For example, if the bridge is already initialized.
439 * @exception UnavailableException
440 * if the portlet cannot perform the initialization at this time.
441 */
442 public void init(PortletConfig config) throws BridgeException;
443
444 /**
445 * Called by the portlet when it wants the bridge to process an action request.
446 *
447 * @param request
448 * the request object.
449 * @param response
450 * the response object.
451 * @throws BridgeDefaultViewNotSpecifiedException
452 * thrown if the request indicates to the Bridge that is should use the default ViewId
453 * and the portlet hasn't supplied one.
454 * @throws BridgeUninitializedException
455 * thrown if the bridge is not initialized.
456 * @throws BridgeException
457 * all other internal exceptions are converted to a BridgeException.
458 */
459 public void doFacesRequest(ActionRequest request,
460 ActionResponse response) throws BridgeDefaultViewNotSpecifiedException,
461 BridgeUninitializedException,
462 BridgeException;
463
464 /**
465 * Called by the portlet when it wants the bridge to process an event request.
466 *
467 * @param request
468 * the request object.
469 * @param response
470 * the response object.
471 * @throws BridgeUninitializedException
472 * thrown if the bridge is not initialized.
473 * @throws BridgeException
474 * all other internal exceptions are converted to a BridgeException.
475 */
476 public void doFacesRequest(EventRequest request,
477 EventResponse response) throws BridgeUninitializedException,
478 BridgeException;
479
480
481 /**
482 * Called by the portlet when it wants the bridge to process a render request.
483 *
484 * @param request
485 * the request object.
486 * @param response
487 * the response object.
488 * @throws BridgeDefaultViewNotSpecifiedException
489 * thrown if the request indicates to the Bridge that is should use the default ViewId
490 * and the portlet hasn't supplied one.
491 * @throws BridgeUninitializedException
492 * thrown if the bridge is not initialized.
493 * @throws BridgeException
494 * all other internal exceptions are converted to a BridgeException.
495 */
496 public void doFacesRequest(RenderRequest request,
497 RenderResponse response) throws BridgeDefaultViewNotSpecifiedException,
498 BridgeUninitializedException,
499 BridgeException;
500
501 /**
502 * Called by the portlet when it wants the bridge to process an in-protocol
503 * resource request.
504 *
505 * @param request
506 * the request object.
507 * @param response
508 * the response object.
509 * @throws BridgeUninitializedException
510 * thrown if the bridge is not initialized.
511 * @throws BridgeException
512 * all other internal exceptions are converted to a BridgeException.
513 */
514 public void doFacesRequest(ResourceRequest request,
515 ResourceResponse response) throws BridgeUninitializedException,
516 BridgeException;
517
518 /**
519 * Called by the portlet to take the bridge out of service. Once out of service, the bridge must
520 * be reinitialized before processing any further requests.
521 */
522 public void destroy();
523
524 }