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 preserve 096 * action parameters received by this portlet along with bridge's request scope so 097 * that they may be restored and acessed in subsequent renders. If "true", the 098 * action parameters are preserved. If "false", they are not preserved. The bridge 099 * default is "false".<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() + preserveActionParams 104 */ 105 public static final String PRESERVE_ACTION_PARAMS = "preserveActionParams"; 106 107 108 /** A PortletContext attribute that a portlet can set prior 109 * to calling the bridge's init() method to configure the bridge to exclude 110 * specific attributes from its bridge request scope. Value is a comma delimited 111 * list containing either a fully qualified attribute name or package name terminated 112 * with a ".*" wildcard indicator. In this later case, all attributes in the package 113 * name which precedes the ".*" are excluded, non recursive.<br> 114 * 115 * As this attribute is scoped to a specific portlet in an application-wide context 116 * the attribute name must be include the portlet name as follows: 117 * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + excludedRequestAttributes 118 */ 119 public static final String EXCLUDED_REQUEST_ATTRIBUTES = "excludedRequestAttributes"; 120 121 /** PortletContext attribute that a portlet must set prior 122 * to calling the bridge's init() method to convey to the bridge the set of default 123 * viewIds that correspond to this portlet's supported <code>PortletMode</code>s. 124 * Its value is a Map with one entry per mode. The mode name is the key. The entry's 125 * value is the corresponding default viewId the bridge should use for this mode. 126 * <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() + DEFAULT_VIEWID_MAP 131 */ 132 public static final String DEFAULT_VIEWID_MAP = "defaultViewIdMap"; 133 134 /** PortletContext attribute that a portlet can set prior to calling the bridge's 135 * init() method to configure the response class the bridge uses/sets when it 136 * dispatches to render a portlet or a resource. The attribute's value is expected to be a class 137 * instance that implements <code>javax.portlet.faces.BridgeWriteBehindResponse</code> 138 * Because the WriteBehind JSP support 139 * is Faces implementation specific, implementations differ depending on both the 140 * Faces provider and its version. Developers therefore must configure the 141 * appropriate class for a given environment. <p> 142 * Note: in Portlet 1.0 Bridge, because it lacked wrapper support, this behavior 143 * was supported by using a servlet filter to wrap the response. The bridge's 144 * default mechanism (i.e. when a portlet hasn't configured a specific class) 145 * preserves the support for such filters. That is by default the Portlet 2.0 146 * bridge is backwards compatible with an implementation used in a Portlet 1.0 environment.<p> 147 * It is also important to note that the Portlet 1.0 Bridge mechanism which uses 148 * servlet filters and the Portlet 2.0 Bridge mechanism of implementing the same 149 * support in a Portlet <code>ResponseWrapper<code> are unlikely to work together. 150 * <br> 151 * 152 * As this attribute is scoped to a specific portlet in an application-wide context 153 * the attribute name must be include the portlet name as follows: 154 * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + WRITE_BEHIND_RESPONSE 155 */ 156 public static final String WRITE_BEHIND_RESPONSE = "writeBehindResponse"; 157 158 // The following are request attributes a portlet can set to control the request 159 // processing of the bridge. 160 161 /** PortletRequest attribute that a portlet may set prior 162 * to calling the bridge's doFacesRequest() method. The value of this 163 * attribute is a <code>String</code> representing the Faces viewId the 164 * bridge is to target for this request. Used by a portlet to specifically 165 * control a request's view target in situations such as navigating from 166 * a nonFaces view to a specific Faces view (other than the default).<p> 167 * Generally, the use of this attribute is mutually exclusive with the use 168 * of VIEW_PATH. If both have been set in a given request, the bridge gives 169 * precedence to VIEW_ID. 170 */ 171 public static final String VIEW_ID = BRIDGE_PACKAGE_PREFIX + "viewId"; 172 173 /** PortletRequest attribute that a portlet may set prior 174 * to calling the bridge's doFacesRequest() method. The value of this 175 * attribute is a <code>String</code> containing a <code>ContextPath</code> 176 * relative path in which the Faces viewId is encoded. Like VIEW_ID, this 177 * attribute provides a means for a portlet to explicitly control the Faces 178 * target for a specific request. It is used in situations such as navigating from 179 * a nonFaces view to a specific Faces view (other than the default).<p> 180 * Generally, the use of this attribute is mutually exclusive with the use 181 * of VIEW_PATH. If both have been set in a given request, the bridge gives 182 * precedence to VIEW_ID. 183 */ 184 public static final String VIEW_PATH = BRIDGE_PACKAGE_PREFIX + "viewPath"; 185 186 // Names for special QueryString parameters names the Bridge recognizes in 187 // encodeActionURL as signifying to change the corresponding portlet values 188 // in the resulting URL 189 190 /** 191 * Special token parameter in the url passed to the bridge's ExternalContext.encodeActionURL() 192 * that it recognizes as an indication that this action should encode a PortletMode 193 * change to the one indicated by the parameter's value. 194 */ 195 public static final String PORTLET_MODE_PARAMETER = BRIDGE_PACKAGE_PREFIX + "PortletMode"; 196 197 /** 198 * Special token parameter in the url passed to the bridge's ExternalContext.encodeActionURL() 199 * that it recognizes as an indication that this action should encode a WindowState change to 200 * the one indicated by the parameter's value. 201 */ 202 public static final String PORTLET_WINDOWSTATE_PARAMETER = BRIDGE_PACKAGE_PREFIX + "WindowState"; 203 204 /** 205 * Special token parameter in the url passed to the bridge's ExternalContext.encodeActionURL() 206 * that it recognizes as an indication that this action should encode a security level change to 207 * the one indicated by the parameter's value. 208 */ 209 public static final String PORTLET_SECURE_PARAMETER = BRIDGE_PACKAGE_PREFIX + "Secure"; 210 211 /** 212 * Special token parameter in the url passed to the bridge's ExternalContext.encodeActionURL() 213 * that it recognizes as an indication that this action should be treated as a direct link 214 * and hence shouldn't be encoded as a Portlet action. Rather encodeActionURL merely returns 215 * this url unchanged. 216 */ 217 public static final String DIRECT_LINK = BRIDGE_PACKAGE_PREFIX + "DirectLink"; 218 219 /** 220 * Special token parameter in the url passed to the bridge's ExternalContext.encodeResourceURL() 221 * that it recognizes as an indication that this resource should be handled in protocol. 222 */ 223 public static final String IN_PROTOCOL_RESOURCE_LINK = 224 BRIDGE_PACKAGE_PREFIX + "InProtocolResourceLink"; 225 226 /** 227 * Special token parameter in the url passed to the bridge's ExternalContext.encodeResourceURL() 228 * that it recognizes as an indication that an URL refering back to the page which 229 * contains this portlet should be encoded in the resource url. This reference is 230 * encoded as the value of a query string parameter whose name is the value of this back 231 * link token parameter. 232 */ 233 public static final String BACK_LINK = BRIDGE_PACKAGE_PREFIX + "BackLink"; 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 url refers to Faces view (navigation) and 238 * hence should be encoded as an portlet ActionURL rather then a portlet resource url. This token 239 * is intended for use in urls signifying a view navigation using components such as 240 * <code>h:outputLink</code>. 241 */ 242 public static final String VIEW_LINK = BRIDGE_PACKAGE_PREFIX + "ViewLink"; 243 244 245 // Request attributes set by the bridge that can be used by Faces extensions 246 // and/or applications to properly run in a portlet environment. 247 248 /** 249 * A PortletRequest attribute set by the bridge when processing a Faces request 250 * that signals this request is a Faces postback. Its provided as 251 * an alternative signal to the common reliance on the view state parameter as 252 * an indicator that this is a postback request. Implementations needing this 253 * information and not using the view state parameter indicator can check this 254 * attribute when running in a portlet environment. 255 */ 256 public static final String IS_POSTBACK_ATTRIBUTE = BRIDGE_PACKAGE_PREFIX + "isPostback"; 257 258 /** A PortletRequest attribute set by the bridge in its 259 * <code>ViewHandler.renderView</code> prior to dispatching the request 260 * to the view (jsp)to indicating a filter should 261 * put the AFTER_VIEW_CONTENT in a buffer on the request for it to process after 262 * rendering the view components. In conjunction with the filter this enables 263 * preserving rendering order of native JSP rendering and Faces rendering in a jsp. 264 */ 265 public static final String RENDER_CONTENT_AFTER_VIEW = 266 BRIDGE_PACKAGE_PREFIX + "RenderContentAfterView"; 267 268 /** A PortletRequest attribute set by an include filter in recognition of the 269 * RenderContentAfterView bridge attribute. Its value is either char[] or byte[] 270 * holding the AFTER_VIEW_CONTENT generated while rendering this jsp. 271 * In conjunction with the bridge this enables 272 * preserving rendering order of native JSP rendering and Faces rendering in a jsp. 273 */ 274 public static final String AFTER_VIEW_CONTENT = BRIDGE_PACKAGE_PREFIX + "AfterViewContent"; 275 276 /** PortletRequest attribute set by the bridge prior to creating/acquiring a 277 * <code>FacesContext</code>. Its value indicates which portlet phase this 278 * Faces is executing in. It can be used by Faces subsystems not only to determine 279 * the portlet exectution phase but if present (not null) as an indication the request 280 * is being processed in a portlet container. 281 */ 282 public static final String PORTLET_LIFECYCLE_PHASE = BRIDGE_PACKAGE_PREFIX + "phase"; 283 284 /** PortletSession attribute set by the bridge to hold the last viewId accessed in a given mode. 285 * The attribute (key) is composed of this name + the mode name. I.e. 286 * javax.portlet.faces.viewIdHistory.view. There is one attribute per supported portlet 287 * mode. The attributes are always set even if the user session has never entered the 288 * mode. Its initial setting/value is determined by the default viewId configured 289 * for the mode. Attribute is used by developers to reference/return to the last view in 290 * a given Mode from another mode. 291 */ 292 public static final String VIEWID_HISTORY = BRIDGE_PACKAGE_PREFIX + "viewIdHistory"; 293 294 295 /** Name of PortletResponse property set by the bridge when it recognizes that the 296 * view has been rendered using a <code>NamingContainer</code> that ensures all 297 * generated ids are namespaced using the consumer provided unique portlet id. 298 */ 299 public static final String PORTLET_NAMESPACED_RESPONSE_PROPERTY = 300 "X-JAVAX-PORTLET-FACES-NAMESPACED-RESPONSE"; 301 302 /** Name of the render parameter set by the bridge when it encodes a navigation 303 * link to a nonFaces target. Though the bridge recognizes nonFaces targets when 304 * it encodes a navigational link, it does not handle the subsequent request. 305 * It only handles requests for Faces targets. It is the portlet's responsibility 306 * to detect and handle these requests. When the nonFaces target is a path based 307 * resource (such as a jsp or servlet), the <code>ContextPath</code> relative path 308 * of the resource is written as the value of this render parameter. For convenience, 309 * the GenericFacesPortlet recognizes this render parameter in received requests 310 * and uses the <code>PortletRequestDispatcher</code> to dispatch to the encoded 311 * path instead of calling the bridge to execute the request. 312 */ 313 public static final String NONFACES_TARGET_PATH_PARAMETER = "_jsfBridgeNonFacesView"; 314 315 /** Name of a request parameter (generally) encoded in a link from a nonFaces 316 * view response. It acts as a marker to the portlet that the nonFaces view 317 * intends to navigate to the Faces view expressed in the value of this parameter. 318 * It differs from the <code>FACES_VIEW_PATH_PARAMETER</code> in that its value 319 * is the actual Faces viewId of the target while the formaer is a 320 * <code>ContextPath</code> relative path containing the viewId.<p> 321 * Portlets receiving such a parameter should set the the corresponding request 322 * attribute <code>javax.portlet.faces.viewId</code> before calling the bridge 323 * to handle the request. 324 */ 325 public static final String FACES_VIEW_ID_PARAMETER = "_jsfBridgeViewId"; 326 327 /** Name of a request parameter (generally) encoded in a link from a nonFaces 328 * view response. It acts as a marker to the portlet that the nonFaces view 329 * intends to navigate to the Faces view expressed in the value of this parameter. 330 * It differs from the <code>FACES_VIEW_ID_PARAMETER</code> in that its value 331 * is a <code>ContextPath</code> relative path containing the viewId while the former 332 * is the viewId itself.<p> 333 * Portlets receiving such a parameter should set the the corresponding request 334 * attribute <code>javax.portlet.faces.viewPath</code> before calling the bridge 335 * to handle the request. 336 */ 337 public static final String FACES_VIEW_PATH_PARAMETER = "_jsfBridgeViewPath"; 338 339 /** A PortletContext attribute that a portlet can set prior 340 * to calling the bridge's init() method to configure the bridge to use/call 341 * the associated eventHandler when processing an event. Value is an instance of 342 * <code>BridgeEventHandler</code>. 343 * 344 * As this attribute is scoped to a specific portlet in an application-wide context 345 * the attribute name must be include the portlet name as follows: 346 * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + bridgeEventHandler 347 */ 348 public static final String BRIDGE_EVENT_HANDLER = "bridgeEventHandler"; 349 350 /** A PortletContext attribute that a portlet can set prior 351 * to calling the bridge's init() method to configure the bridge to use/call 352 * the associated publicRenderParameterHandler. This handler is used to 353 * process updates that result from public render parameter changes passed in 354 * a request. The bridge first pushs all the public render parameter values into the models and 355 * then calls this handler's processUpdates method. The handler can then compute 356 * further model changes based on the changes. Value is an instance of 357 * <code>BridgePublicRenderParameterHandler</code>. 358 * 359 * As this attribute is scoped to a specific portlet in an application-wide context 360 * the attribute name must be include the portlet name as follows: 361 * BRIDGE_PACKAGE_PREFIX + context.getPortletName() + bridgeEventHandler 362 */ 363 public static final String BRIDGE_PUBLIC_RENDER_PARAMETER_HANDLER = "bridgePublicRenderParameterHandler"; 364 365 /** Special value recognized during <code>encodeActionURL</code> of a portlet: url containing either 366 * the <code>_jsfBridgeViewId</code> or <code>_jsfBridgeViewPath</code> parameter. 367 * <code>encodeActionURL</code> recognizes this value as indicating it needs to generate and 368 * encode an URL to the current JSF including its current state. I.e. It not only 369 * encodes the link reference but also the existing render parameters so they can be carried forward 370 * to reestablish the state. 371 */ 372 public static final String FACES_USE_CURRENT_VIEW_PARAMETER = "_jsfBridgeCurrentView"; 373 374 375 /** Enumeration whose values describe the current portlet phase the bridge 376 * is executing Faces within. 377 */ 378 public static enum PortletPhase 379 { 380 ACTION_PHASE, 381 RENDER_PHASE, 382 EVENT_PHASE, 383 RESOURCE_PHASE, 384 ; 385 } 386 387 /** Enumeration whose values describe the render policy used by the bridge 388 * to render portlets in this application. A policy of DEFAULT indicates 389 * the bridge will first delegate rendering and if this results in an 390 * exception being thrown will render the itself. A policy of ALWAYS_DELEGATE 391 * indicates the bridge will always delegate rendering, never rendering itself. 392 * A policy of NEVER_DELEGATE indicates the bridge will always render itself without 393 * delegating. 394 */ 395 public static enum BridgeRenderPolicy 396 { 397 DEFAULT, 398 ALWAYS_DELEGATE, 399 NEVER_DELEGATE, 400 ; 401 } 402 403 /** 404 * Called by the portlet. It indicates that the bridge is being placed into service. 405 * <p> 406 * The portlet calls the <code>init</code> method exactly once before invoking other lifecycle 407 * methods. Usually, done immediately after instantiating the bridge. The <code>init</code> 408 * method must complete successfully before the bridge can receive any requests. 409 * <p> 410 * The portlet cannot place the bridge into service if the <code>init</code> method Throws a 411 * <code>BridgeException</code>. 412 * <p> 413 * Initialization context is passed to bridge via <code>PortletContext</code> attributes. The 414 * following attributes are defined: 415 * <ul> 416 * <li><code>javax.portlet.faces.encodeRedirectURL</code>: instructs the bridge to call 417 * <code>ExternalContext.encodeActionURL()</code> before processing the redirect request. This 418 * exists because some (newer) versions of JSF 1.2 call <code>encodeActionURL</code> before 419 * calling <code>redirect</code> while others do not. This flag adjusts the behavior of the 420 * bridge in accordance with the JSF 1.2 implementation it runs with. 421 * <li><code>javax.portlet.faces.numManagedActionScopes</code>: defines the maximum number of 422 * actionScopes this bridge preserves at any given time. Value is an integer. ActionScopes are 423 * managed on a per Bridge class portlet context wide basis. As a typical portlet application uses 424 * the same bridge implementation for all its Faces based portlets, this means that all 425 * actionScopes are managed in a single bucket.<br> 426 * For convenience this interface defines the <code>NUM_MANAGED_ACTIONSCOPES</code> constant. 427 * <li><code>javax.faces.lifecycleID</code>: defines the Faces <code>Lifecycle</code> id 428 * that bridge uses when acquiring the <code>Faces.Lifecycle</code> via which it executes the 429 * request. As a context wide attribute, all bridge instances in this portlet application will use 430 * this lifecyle. 431 * <li><code>javax.portlet.faces.[portlet name].preserveActionParams</code>: instructs the 432 * bridge to preserve action parameters in the action scope and represent them in subsequent 433 * renders. Should be used only when binding to a Faces implementation that relies on accessing 434 * such parameters during its render phase. As this is a portlet/bridge instance specific 435 * attribute, the <code>PortletContext</code>attribute name is qualified by the portlet 436 * instance name. This allows different portlets within the same portlet application to have 437 * different settings.<br> 438 * For convenience this interfaces defines a number of constants that simplifies constructing 439 * and/or recognizing this name. 440 * </ul> 441 * 442 * @param config 443 * a <code>PortletConfig</code> object containing the portlet's configuration and 444 * initialization parameters 445 * @exception BridgeException 446 * if an exception has occurred that interferes with the bridge's normal operation. 447 * For example, if the bridge is already initialized. 448 * @exception UnavailableException 449 * if the portlet cannot perform the initialization at this time. 450 */ 451 public void init(PortletConfig config) throws BridgeException; 452 453 /** 454 * Called by the portlet when it wants the bridge to process an action request. 455 * 456 * @param request 457 * the request object. 458 * @param response 459 * the response object. 460 * @throws BridgeDefaultViewNotSpecifiedException 461 * thrown if the request indicates to the Bridge that is should use the default ViewId 462 * and the portlet hasn't supplied one. 463 * @throws BridgeUninitializedException 464 * thrown if the bridge is not initialized. 465 * @throws BridgeException 466 * all other internal exceptions are converted to a BridgeException. 467 */ 468 public void doFacesRequest(ActionRequest request, 469 ActionResponse response) throws BridgeDefaultViewNotSpecifiedException, 470 BridgeUninitializedException, 471 BridgeException; 472 473 /** 474 * Called by the portlet when it wants the bridge to process an event request. 475 * 476 * @param request 477 * the request object. 478 * @param response 479 * the response object. 480 * @throws BridgeUninitializedException 481 * thrown if the bridge is not initialized. 482 * @throws BridgeException 483 * all other internal exceptions are converted to a BridgeException. 484 */ 485 public void doFacesRequest(EventRequest request, 486 EventResponse response) throws BridgeUninitializedException, 487 BridgeException; 488 489 490 /** 491 * Called by the portlet when it wants the bridge to process a render request. 492 * 493 * @param request 494 * the request object. 495 * @param response 496 * the response object. 497 * @throws BridgeDefaultViewNotSpecifiedException 498 * thrown if the request indicates to the Bridge that is should use the default ViewId 499 * and the portlet hasn't supplied one. 500 * @throws BridgeUninitializedException 501 * thrown if the bridge is not initialized. 502 * @throws BridgeException 503 * all other internal exceptions are converted to a BridgeException. 504 */ 505 public void doFacesRequest(RenderRequest request, 506 RenderResponse response) throws BridgeDefaultViewNotSpecifiedException, 507 BridgeUninitializedException, 508 BridgeException; 509 510 /** 511 * Called by the portlet when it wants the bridge to process an in-protocol 512 * resource request. 513 * 514 * @param request 515 * the request object. 516 * @param response 517 * the response object. 518 * @throws BridgeUninitializedException 519 * thrown if the bridge is not initialized. 520 * @throws BridgeException 521 * all other internal exceptions are converted to a BridgeException. 522 */ 523 public void doFacesRequest(ResourceRequest request, 524 ResourceResponse response) throws BridgeUninitializedException, 525 BridgeException; 526 527 /** 528 * Called by the portlet to take the bridge out of service. Once out of service, the bridge must 529 * be reinitialized before processing any further requests. 530 */ 531 public void destroy(); 532 533 }