30 Coding Portlets

30.1.1 How to Add Personalization

As a quick example of adding personalization, you can enhance the portlet you created in Section 29.2.1, "How to Create a JSR 168 Java Portlet" with some code that enables a user in Edit or Edit Defaults mode to paste HTML into a field for the portlet to render. You can then easily redeploy the portlet and then test it.

Before You Begin

The steps that follow assume that you have:

• Built a portlet using the Create JSR 168 Java Portlet wizard in JDeveloper. For more information, see Section 29.2.1, "How to Create a JSR 168 Java Portlet."

• Added a preference called portletContent in the Customization Preferences page of the wizard.

• Registered the producer with a custom WebCenter application and added the portlet to a page. For more information, see Section 9.2.1, "How to Register a WSRP Portlet Producer" and Section 9.3.1, "How to Add a Portlet to a Page."

• Enabled Oracle ADF security for the application. For more information, see Section 24.3, "Setting Up Security for Your Application."

  The user must be logged in to the application as an authenticated user to access the personalization feature.

To implement simple personalization:

1. Start JDeveloper.

2. In the Application Navigator, open the application that contains the portlet.

3. Expand the project that contains the portlet.

4. Right-click view.jsp and choose Open.

5. In the visual editor, click the Source tab and add the code indicated in bold in Example 30-1 to display the portletContent customization preference:

   Example 30-1 view.jsp Sample Code

   <%@ page contentType="text/html"
       import="javax.portlet.*,java.util.*,Portlets.Portlet1,
       Portlets.resource.Portlet1Bundle"%>
   <%@ taglib uri="http://java.sun.com/portlet" prefix="portlet"%>
   
   <portlet:defineObjects/>
   <%
   String[] str = {"Portlet Content"};
   PortletPreferences prefs = renderRequest.getPreferences();
   str = prefs.getValues("portletContent",str);
   for (int i=0; i<str.length; i++)
   {
   %><%=(i<str.length-1)?str[i]+", ":str[i]%><%}%> 
   

6. In the Application Navigator, right-click edit.jsp and choose Open.

   Notice that the JSP consists of a form field, a form input field, and two form button fields.

7. In the visual editor, click the Source tab and add the code indicated in bold in Example 30-2 to implement a form field for users to enter a value for the portletContent customization preference:

   Example 30-2 edit.jsp Sample Code

   <%@ page contentType = "text/html; charset=windows-1252"
            pageEncoding = "windows-1252"
            import = "javax.portlet.*, java.util.*,
   Portletenhance.Portletenhance,
   Portletenhance.resource.PortletenhanceBundle"%>
   @ <%@ taglib uri = "http://java.sun.com/portlet" prefix="portlet"%>
   <portlet:defineObjects/>
   <%
       PortletPreferences prefs = renderRequest.getPreferences();
       ResourceBundle res =
           portletConfig.getResourceBundle(renderRequest.getLocale());
   %>
   <form action="<portlet:actionURL/>" method="POST">
     <table border="0">
       <tr>
         <td width="20%">
           <p class="portlet-form-field" align="right">
             <%=  res.getString(PortletenhanceBundle.PORTLETCONTENT) %>
           </p>
         </td>
         <td width="80%">
           <input class="portlet-form-input-field"
                  type="TEXT"
                  name="<%= Portletenhance.PORTLETCONTENT_KEY %>"
                  value="<%= Portletenhance.buildValue(prefs,
   Portletenhance.PORTLETCONTENT_KEY) %>"
                  size="20">
         </td>
       </tr>    <tr>
         <td width="20%">
           <p class="portlet-form-field" align="right">
             <%=  res.getString(PortletenhanceBundle.PORTLETTITLE) %>
           </p>
         </td>
         <td width="80%">
           <input class="portlet-form-input-field"
                  type="TEXT"
                  name="<%= Portletenhance.PORTLETTITLE_KEY %>"
                  value="<%= prefs.getValue(Portletenhance.PORTLETTITLE_KEY,
   res.getString("javax.portlet.title")) %>"
                  size="20">
         </td>
       </tr>
       <%
       String[] str = {"Portlet Content"};
       str = prefs.getValues("portletContent",str);
   %>
   <tr><td width="20%">
   <p class="portlet-form-field" align="right">
   Content
   </p>
   </td><td width="80%">
   <textarea rows="10" cols="60" class="portlet-form-input-field"
     name="portletContent"><%
   for (int i=0; i<str.length; i++)
   {%><%= (i<str.length-1) ? str[i]+", " : str[i] %><%}%>
   </textarea>
   </td></tr>
       <tr>
         <td colspan="2" align="center">
           <input class="portlet-form-button" type="submit"
                                               
   name="<%=Portletenhance.OK_ACTION%>"
                                               
   value="<%=res.getString(PortletenhanceBundle.OK_LABEL)%>">
           <input class="portlet-form-button" type="submit"
                                               
   name="<%=Portletenhance.APPLY_ACTION%>"
                                               
   value="<%=res.getString(PortletenhanceBundle.APPLY_LABEL)%>">
         </td>
       </tr>
     </table>
   </form>
   

8. In the Application Navigator, right-click portletName.java and choose Open.

9. In the visual editor, click the Source tab and add the following two lines of code (indicated in bold) to the processAction method:

   // Save the preferences.
   PortletPreferences prefs = request.getPreferences();
   String param = request.getParameter(PORTLETTITLE_KEY);
   prefs.setValues(PORTLETTITLE_KEY, buildValueArray(param));
   String contentParam = request.getParameter("portletContent");
   if (contentParam != null)
   {
     prefs.setValues("portletContent", buildValueArray(contentParam));
   }
   prefs.store();
   

10. Redeploy the portlet.

    Notice that JDeveloper automatically saves and compiles the code before deploying the portlet. For a reminder of how to perform this step, see Chapter 33, "Testing and Deploying Your Portlets."

11. Reload the page that contains the portlet and you can see that the portlet now displays the text Portlet Content, which was one of the changes you made.

12. Click the Personalize link to see the form field that you added. Enter some text in this field and close the dialog. You can see the new text displayed in the portlet.

30.1.2 How to Implement Navigational Parameters (WSRP 2.0)

While JSR 168 and WSRP 1.0 do not address public portlet parameters, WSRP 2.0 introduces navigational parameters to enable inter-portlet communication. With the release of the new portlet Application Programming Interface (API) standard, JSR 286, the need for vendor-specific API extensions will not be necessary any more. Until then, you are required to use the Oracle-specific portlet container and API extensions.

Using the Create JSR 168 Java Portlet wizard, you can easily create a portlet with navigational parameters. When you register the producer and drop the portlet on a page, the portlet's parameters are automatically linked to page variables.

To add public parameters to JSR 168 portlets using WSRP 2.0 navigational parameters:

1. Start JDeveloper.

2. In the Application Navigator, open the application under which you want to create the portlet.

3. Right-click the project under which you want to create the portlet and choose New.

4. In the New Gallery, expand Web Tier, select Portlets and then Standards-based Java Portlet (JSR 168), and click OK.

5. In the General Portlet Information page of the Create JSR 168 Java Portlet wizard, select Enable inter-portlet communication using Oracle WSRP V2 extensions as shown in Figure 30-1.

   Figure 30-1 Creating a Portlet with Navigational Parameters

   
   Description of "Figure 30-1 Creating a Portlet with Navigational Parameters"
   
   

6. Proceed through the wizard until you reach the Portlet Navigation Parameters page. For basic information about going through the wizard, see Section 29.2.1, "How to Create a JSR 168 Java Portlet."

7. In the Portlet Navigation Parameters page (Figure 30-2), click Add.

   This adds a new row to the table of parameters.

   Figure 30-2 Portlet Navigation Parameters Page of Portlet Wizard

   
   Description of "Figure 30-2 Portlet Navigation Parameters Page of Portlet Wizard"
   
   

8. Replace the default values in the Name, Label, and Hint fields with something more meaningful for your parameter.

9. Add more parameters as required and then click Finish.

10. In the Applications Navigator, right-click oracle-portlet.xml and choose Open.

    You should see entries for the parameters that you added when you created the portlet, as shown in Example 30-3.

    Example 30-3 oracle-portlet.xml Sample, Navigational Parameters

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <portlet-app-extension
     xsi:schemaLocation="http://xmlns.oracle.com/portlet/oracle-portlet-app"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns="http://xmlns.oracle.com/portlet/oracle-portlet-app">
        <portlet-extension>
            <portlet-name>portlet1</portlet-name>
            <navigation-parameters>
                <name>Parameter_01</name>
                <type>xsi:string</type>
                <label xml:lang="en">Parameter 1</label>
                <hint xml:lang="en">First parameter.</hint>
            </navigation-parameters>
            <navigation-parameters>
                <name>Parameter_02</name>
                <type>xsi:string</type>
                <label xml:lang="en">Parameter 2</label>
                <hint xml:lang="en">Second parameter.</hint>
            </navigation-parameters>
            <portlet-id>1164232649525</portlet-id>
        </portlet-extension>
    </portlet-app-extension>
    

11. Add code to the portlet that utilizes the parameters.

    When the parameters are included in the oracle-portlet.xml file, you can access and set them as you would any normal render parameter, and the values are automatically exposed by the consumer.

    For an example of a portlet used to set the values of navigation parameters, see the Parameter Form portlet, provided with the sample WSRP producer.

12. You can use the following APIs to read parameters passed to the portlet.

    String param1 = request.getParameter("Parameter_01");
    String param2 = request.getParameter("Parameter_02");
    

    For an example of a portlet used to read and display the values of navigation parameters, see the Parameter Display portlet, provided with the sample WSRP producer.

13. Application developers can add these portlets to a page and link them using the navigational parameters. For more information, see Section 9.7, "Contextually Linking WSRP 2.0 Portlets."

30.1.3 How to Implement Export/Import of Customizations (WSRP 2.0)

Another new feature that arrives with WSRP 2.0 is the ability to keep customizations with portlets when moving them from one deployment to another. Customizations are portlet preferences that are set in edit defaults mode. For example, suppose that you create a portlet and then customize its title within your development environment. If you have enabled export and import for that portlet and its producer, then the customized title is transported along with the portlet when you deploy it in production environment. If you do not enable export and import, then all customizations are lost when you transport the portlet from one deployment environment to another.

To implement export or import for a portlet and its producer:

1. Start JDeveloper.

2. In the Application Navigator, open the application that contains the portlet.

3. Expand the project that contains the portlet.

4. Right-click the oracle-portlet.xml file for the portlet's producer and choose Open.

5. Ensure that the allow-export and allow-import tags are included for each portlet and the producer as shown in Example 30-4, adding them if necessary.

   Example 30-4 oracle-portlet.xml Sample, Export/Import

   <portlet-app-extension xsi:schemaLocation="./oracle-portlet-app.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns="./oracle-portlet-app.xsd">
       <portlet-extension>
           <portlet-name>portlet1</portlet-name>
           <navigation-parameters>
               <name>Parameter_01</name>
               <type>xsi:string</type>
               <label xml:lang="en">First Parameter</label>
               <hint xml:lang="en">hint0</hint>
           </navigation-parameters>
           <navigation-parameters>
               <name>Parameter_02</name>
               <type>xsi:string</type>
               <label xml:lang="en">Second Parameter</label>
               <hint xml:lang="en">hint1</hint>
           </navigation-parameters>
           <navigation-parameters>
               <name>Parameter_03</name>
               <type>xsi:string</type>
               <label xml:lang="en">Third Parameter</label>
               <hint xml:lang="en">hint2</hint>
           </navigation-parameters>
           <portlet-id>1</portlet-id>
           <allow-export>true</allow-export>
           <allow-import>true</allow-import>
           <portlet-name>portlet2</portlet-name>
           <navigation-parameters>
               <name>Parameter_01</name>
               <type>xsi:string</type>
               <label xml:lang="en">First Parameter</label>
               <hint xml:lang="en">hint0</hint>
           </navigation-parameters>
           <navigation-parameters>
               <name>Parameter_02</name>
               <type>xsi:string</type>
               <label xml:lang="en">Second Parameter</label>
               <hint xml:lang="en">hint1</hint>
           </navigation-parameters>
           <navigation-parameters>
               <name>Parameter_03</name>
               <type>xsi:string</type>
               <label xml:lang="en">Third Parameter</label>
               <hint xml:lang="en">hint2</hint>
           </navigation-parameters>
           <portlet-id>2</portlet-id>
           <allow-export>true</allow-export>
           <allow-import>true</allow-import>
       </portlet-extension>
       <allow-export>true</allow-export>
       <allow-import>true</allow-import>
   </portlet-app-extension>
   

30.1.4 How to Implement Rewritten URLs for Resource Proxy

Resource proxying is the standard way to retrieve resources with WSRP. To avoid problems with URLs within your portlet, you can set a flag to rewrite all of the URLs within a specified resource. For example, if have an HTML fragment that contains URLs, then you could set this flag to rewrite its URLs taking into account the WSRP resource proxying.

To indicate that URLs should be rewritten, set the PortletRequest attribute, oracle.portlet.server.resourceRequiresRewriting, to true. For example, you might include code similar to the excerpt in Example 30-5 to use resource proxying for a URL that you are encoding. Note that typically you would want to encapsulate this code within a method to avoid repeating it for every URL individually.

request.setAttribute("oracle.portlet.server.resourceRequiresRewriting", 
     Boolean.TRUE); 
String url = response.encodeURL(pathToResourceForRewriting); 
request.removeAttribute("oracle.portlet.server.resourceRequiresRewriting");

If you do not specifically set oracle.portlet.server.resourceRequiresRewriting, then it defaults to false, meaning that URLs are not rewritten. You must explicitly activate the feature by setting this attribute to true.

30.1.5 How to Implement Stateless Resource Proxying

If you have out of protocol resources that do not require rewriting, you may want to use stateless resource proxying. Stateless resource proxying means that the URLs returned to the browser do not need to include portlet IDs or any other contextual information. This increases the cache hit ratio for such resources. You might find stateless resource proxying useful for functionality such as static JavaScript files, static images, and so on.

To indicate that stateless proxying should be used, set the PortletRequest attribute oracle.portlet.server.useStatelessProxying to true. For example, you might include code similar to the excerpt in Example 30-6 to use stateless proxying for a URL that you are encoding. Note that typically you would want to encapsulate this code within a method to avoid repeating it for every URL individually.

request.setAttribute("oracle.portlet.server.useStatelessProxying", Boolean.TRUE);
String url = response.encodeURL(pathToResource);
request.removeAttribute("oracle.portlet.server.useStatelessProxying");

You can also use the following constant:

oracle.portlet.server.containerimpl.PortletRequestImpl.USE_STATELESS_PROXYING

This is shown in Example 30-7.

request.setAttribute(PortletRequestImpl.USE_STATELESS_PROXYING, Boolean.TRUE);
String url = response.encodeURL(pathToResource);
request.removeAttribute(PortletRequestImpl.USE_STATELESS_PROXYING);

If you do not specifically set oracle.portlet.server.useStatelessProxying, it defaults to false. You must explicitly activate the feature by setting this attribute to true.

30.1.6 How to Disable Java Object Cache for Preference Store Access

In some cases, you may prefer to avoid the use of the Java Object Cache by your WSRP preference store. You can configure the use of caching by the WSRP preference store with the following JNDI variable:

oracle/portal/wsrp/server/disableJavaObjectCache

By default, this variable is set to false. You can set the variable yourself in the web.xml file for you portlet application as follows:

<env-entry>
 <env-entry-name>oracle/portal/wsrp/server/disableJavaObjectCache</env-entry-name>
 <env-entry-type>java.lang.Boolean</env-entry-type>
 <env-entry-value>true</env-entry-value>
</env-entry>

For more information about setting JNDI variables, see Section 30.2.4.2, "Setting JNDI Variable Values."

30.1.7 How to Implement Security for JSR 168 Portlets

You can secure JSR 168 portlets that are deployed to a WSRP producer by configuring security at the WSRP producer end and the client end. For information about securing a JSR 168 portlet through its WSRP producer, see Section 24.12, "Securing Identity Propagation Through WSRP Producers with WS-Security."

30.2.1 How to Add Portlet Modes

In the Portlet Wizard, you add portlet modes by checking boxes on the wizard pages. For more information about using the wizard, see Section 29.2.3, "How to Create a PDK-Java Portlet." For each portlet mode that you select in the wizard, a basic skeleton is created. If you want to add a portlet mode after creating the portlet, you can do that manually by updating provider.xml and HTML or JSPs in JDeveloper.

The principles of implementing portlet modes using RenderManager are the same for all modes.

For more detailed information about the PDK runtime classes used in this section, see the JavaDoc on OTN:

http://www.oracle.com/technology/products/webcenter/portlet_download.html

For more information about the syntax of provider.xml, see the provider JavaDoc, also available on OTN.

Before You Begin

The steps that follow assume that you have:

• Built a portlet using the wizard, successfully registered the producer, and added the portlet to the page.

To add a portlet mode:

1. Start JDeveloper.

2. In the Application Navigator, open the application that contains the portlet.

3. Expand the project that contains the portlet.

4. Expand the Web Content node and then the htdocs node and then the node for the producer.

5. Right-click the node for the portlet and choose New.

   The node for the portlet is located under Web Content > htdocs > provider.

6. In the New Gallery, expand Web Tier, select HTML or JSP, and click OK.

   You must create an HTML file or a JSP for each mode to add to your portlet. For example, to implement Help mode, you would create an HTML file to provide the help content.

7. In the resulting dialog, enter a file name for the HTML file or JSP and click OK.

8. In the visual editor, edit the content of the page to implement the desired functionality.

   For example, for Help mode, you could add the following HTML:

   <p>This is the <i>Help</i> mode of your portlet!</p>
   

9. In the Application Navigator, right-click the provider.xml file for the provider that owns the portlet and choose Open.

   The provider.xml file is located under Web Content > WEB-INF > providers > provider.

10. Change the value of the appropriate tag for the mode you are adding to true.

    For example, if you are adding Help mode, change the hasHelp tag as follows:

    <hasHelp>true</hasHelp>
    

    This indicates to the PDK Framework that a link or icon to that mode should be rendered.

11. Add the code to point to the HTML page or JSP that you created earlier for the mode.

    For example, for the Help page, add the following code:

    <helpPage>/htdocs/myprovider/myportlet/myHelpPage.html</helpPage>
    

12. Save your changes.

13. Redeploy your portlet. For more information, see Chapter 33, "Testing and Deploying Your Portlets."

    When you redeploy, JDeveloper automatically saves and compiles the code before deploying the portlet.

14. Copy the HTML file or JSP you created and the updated provider.xml file to the WLS instance where you plan to deploy the portlet.

15. Refresh the producer.

16. Refresh the page containing your portlet.

    You should now be able to access the new mode. For example, if you added Help mode, you should be able to click the Help link.

30.2.2 How to Implement Public Parameters

PDK-Java and Oracle WebCenter Framework provide public and private portlet parameters to enable portlet developers to easily write reusable, complex portlets. The Portlet Wizard in JDeveloper creates portlets that are set up to use parameters. This feature enables you to focus solely on adding business logic to your portlets and does not require any changes to provider.xml.

For an overview of parameters, see Section 27.2.11, "Public Portlet Parameter Support" and Section 27.2.12, "Private Portlet Parameter Support."

Before You Begin

The steps that follow assume that you have:

• Followed through and understood Section 29.2.3, "How to Create a PDK-Java Portlet."

• Built a portlet using the wizard and successfully added it to a page.

Using the Portlet Wizard, you can easily create a portlet with public parameters. When you register the producer and drop the portlet on a page, the portlet's parameters are automatically linked to page variables.

To create a portlet with public parameters to your portlet:

1. Start JDeveloper.

2. In the Application Navigator, open the application that contains the portlet.

3. Right-click the project under which you want to create your portlet, and choose New.

   Note:

   To create the portlet in an existing producer, right-click the producer's provider.xml file and choose Add Portlet. This takes you directly to the General Portlet Information page of the Create Oracle PDK-Java Portlet wizard.

4. In the New Gallery, expand Web Tier, select Portlets and then Oracle PDK-Java Portlet, and click OK.

5. Proceed through the Create Oracle PDK-Java Portlet wizard as you normally would until you reach the Public Portlet Parameters page.

   See Section 29.2.3, "How to Create a PDK-Java Portlet" for basic information about going through the wizard.

6. In the Public Portlet Parameters page (Figure 30-3), click Add.

   This adds a new row to the table of parameters.

   Figure 30-3 Public Portlet Parameters Page of Portlet Wizard

   
   Description of "Figure 30-3 Public Portlet Parameters Page of Portlet Wizard"
   
   

7. Replace the default values in the Name, Display Name, and Description fields with something more meaningful for your parameter.

8. Add more parameters as required and then click Finish.

9. In the Application Navigator, right-click the provider.xml file for the provider that owns the portlet and choose Open.

   The provider.xml file is located under Web Content > WEB-INF > providers > provider.

   You should see entries for the parameters that you added on the Public Portlet Parameters page in the wizard, for example, as shown in Example 30-8.

   Example 30-8 provider.xml Sample, Public Parameters

   <?xml version = '1.0' encoding = 'UTF-8'?><?providerDefinition version="3.1"?>
   <provider class="oracle.portal.provider.v2.DefaultProviderDefinition">
     <session>false</session>
     <passAllUrlParams>false</passAllUrlParams>
     <preferenceStore class=
        "oracle.portal.provider.v2.preference.FilePreferenceStore">
      <name>prefStore1</name>
      <useHashing>true</useHashing>
     </preferenceStore>
     <portlet class="oracle.portal.provider.v2.DefaultPortletDefinition">
         <id>1</id>
         <name>MyPortlet</name>
         <title>My Portlet</title>
         <description>My Portlet Description</description>
         <timeout>40</timeout>
         <showEditToPublic>false</showEditToPublic>
         <hasAbout>false</hasAbout>
         <showEdit>true</showEdit>
         <hasHelp>false</hasHelp>
         <showEditDefault>false</showEditDefault>
         <showDetails>false</showDetails>
         <inputParameter class=
           "oracle.portal.provider.v2.DefaultParameterDefinition">
          <name>Parameter_01</name>
          <displayName>Parameter_01</displayName>
          <description>My first parameter</description>
         </inputParameter>
         <inputParameter class=
           "oracle.portal.provider.v2.DefaultParameterDefinition">
          <name>Parameter_02</name>
          <displayName>Parameter_02</displayName>
          <description>My second parameter</description>
         </inputParameter>
         <inputParameter class=
           "oracle.portal.provider.v2.DefaultParameterDefinition">
          <name>Parameter_03</name>
          <displayName>Parameter_03</displayName>
         </inputParameter>
         <renderer class="oracle.portal.provider.v2.render.RenderManager">
            <renderContainer>true</renderContainer>
            <renderCustomize>true</renderCustomize>
            <autoRedirect>true</autoRedirect>
            <contentType>text/html</contentType>
            <showPage>/htdocs/myportlet/MyPortletShowPage.jsp</showPage>
            <editPage>/htdocs/myportlet/MyPortletEditPage.jsp</editPage>
         </renderer>
         <personalizationManager class=
           "oracle.portal.provider.v2.personalize.PrefStorePersonalizationManager">
          <dataClass>
           oracle.portal.provider.v2.personalize.NameValuePersonalizationObject
          </dataClass>
         </personalizationManager>
      </portlet>
   </provider>
   

10. In the Application Navigator, right-click the portletnameShowPage.jsp for your portlet and choose Open.

    The file is located under Web Content > htdocs > provider > portlet.

    The portlet includes logic for retrieving the parameters, for example, as shown in Figure 30-3.

    Example 30-9 ShowPage.jsp Sample

    <%@page contentType="text/html; charset=windows-1252"
            import="oracle.portal.provider.v2.render.PortletRenderRequest"
            import="oracle.portal.provider.v2.http.HttpCommonConstants"
            import="oracle.portal.provider.v2.ParameterDefinition"
    %>
    <%
       PortletRenderRequest pReq = (PortletRenderRequest)
          request.getAttribute(HttpCommonConstants.PORTLET_RENDER_REQUEST);
    %>
    <P>Hello <%= pReq.getUser().getName() %>.</P>
    <P>This is the <b><i>Show</i></b> render mode!</P>
    <%
       ParameterDefinition[] params =
           pReq.getPortletDefinition().getInputParameters();
    %>
    <p>This portlet's input parameters are...</p>
    <table align="left" width="50%" ><tr><td><span
    class="PortletHeading1">Name</span></td><td><span
    class="PortletHeading1">Value</span></td></tr>
    <%
       String name = null;
       String value = null;
       String[] values = null;
       for (int i = 0; i < params.length; i++)
       {
           name = params[i].getName();
           values = pReq.getParameterValues(name);
           if (values != null)
           {
               StringBuffer temp = new StringBuffer();
               for (int j = 0; j < values.length; j++)
               {
                   temp.append(values[j]);
                   if (j + 1 != values.length)
                   {
                       temp.append(", ");
                   }
               }
               value = temp.toString();
           }
           else
           {
               value = "No values have been submitted yet.";
           }
    %>
    <tr>
      <td><span class="PortletText2"><%= name %></span></td>
      <td><span class="PortletText2"><%= value %></span></td>
    </tr>
    <%
       }
    %>
    </table>
    

11. Add logic to your portlet that allows it to submit parameter values entered by users.

12. Create a second portlet using the same steps that simply displays parameter values that it retrieves.

13. Register the producer with a WebCenter application. For more information, see Section 9.2.3, "How to Register an Oracle PDK-Java Portlet Producer."

14. Add the two portlets to a page in the application. For more information, see Section 9.3, "Adding Portlets to a Page."

15. In the Structure panel of the Application Navigator, right-click an element of the page and choose Go to Page Definition.

    The page definition should look similar to Example 30-10. Notice the variables at the page level and the parameters at the portlet level (indicated in bold).

    Example 30-10 Page Definition File Sample

    <?xml version="1.0" encoding="UTF-8"?>
    <pageDefinition xmlns="http://xmlns.oracle.com/adfm/uimodel"
                    version="10.1.3.38.90" id="untitled1PageDef"
                    Package="view.pageDefs">
      <executables>
        <variableIterator id="variables">
          <variable Name="portlet1_Parameter_01" Type="java.lang.Object"/>
          <variable Name="portlet1_Parameter_02" Type="java.lang.Object"/>
          <variable Name="portlet1_Parameter_03" Type="java.lang.Object"/>
        </variableIterator>
        <portlet id="portlet1"       portletInstance="/oracle/adf/portlet/PdkPortletProducer1_1153936627784
              /applicationPortlets/Portlet1_abfc5a10_010c_1000_8003_82235f50d831"
            class="oracle.adf.model.portlet.binding.PortletBinding"
            xmlns="http://xmlns.oracle.com/portlet/bindings">
          <parameters>
            <parameter name="Parameter_01" pageVariable="portlet1_Parameter_01"/>
            <parameter name="Parameter_02" pageVariable="portlet1_Parameter_02"/>
            <parameter name="Parameter_03" pageVariable="portlet1_Parameter_03"/>
          </parameters>
        </portlet>
      </executables>
    </pageDefinition>
    

16. Run the WebCenter application.

17. Enter values in the first portlet and the same values should be displayed in the second portlet.

30.2.3 How to Implement Private Parameters

In some cases, you might need a parameter that is known only to the portlet instance. These parameters are known as private parameters because they have no connection to the page and are known only to the portlet. Private parameters often come in handy when you are building navigation for your portlet. For example, if you have a portlet made up of multiple pages, then you can use these private parameters to jump to another resource of the portlet.

http://dictionary.reference.com/search?q=Hedgehog

http://host/portal/page?_pageid=33,1&_dad=portal&_schema=PORTAL
   &_piref33_38279_33_1_1.q=Hedgehog

HttpPortletRendererUtil.portletParameter(HttpServletRequest request, String param);

qualParamQ = HttpPortletRendererUtil.portletParameter(r, "q");

PortletRenderRequest.getQualifiedParameter(String name)

valueQ = r.getQualifiedParameter("q");

portletRenderRequest.getRenderContext().getPageURL()
portletRenderRequest.getRenderContext().getEventURL()
portletRenderRequest.getRenderContext().getDesignURL()
portletRenderRequest.getRenderContext().getLoginServerURL()
portletRenderRequest.getRenderContext().getBackURL()

UrlUtils.constructLink(
    PortletRenderRequest pr,
    int linkType, -- UrlUtils.PAGE_LINK in this case
    NameValue[] params,
    boolean encodeParams,
    boolean replaceParams)

<%
    String paramNameQ = "q";
    String qualParamNameQ = 
    HttpPortletRendererUtil.portletParameter(paramNameQ);
    PortletRenderRequest pRequest = (PortletRenderRequest)
        request.getAttribute(HttpCommonConstants.PORTLET_RENDER_REQUEST);
    String paramValueQ = pRequest.getQualifiedParameter(paramNameQ);
%>
<!-- Output the HTML content -->
<center>
    Words similar to <%= paramValueQ %>
    <br>
    Click the link to search for words related to that word.
    <br>
    <ul>
<%
        String[] relatedWords = Thesaurus.getRelatedWords(paramValueQ);
        NameValue[] linkParams = new NameValue[1]; 
        for (int i=0; i<=relatedWords.length; i++)
        {
            linkParams[0] = new NameValue(
                qualParamNameQ, relatedWords[i]);
%>
            <li>
            <b> <%= relatedWords[i] %> </b>
            <%= UrlUtils.constructHTMLLink(
                pRequest,
                UrlUtils.PAGE_LINK,
                "(words related to " + relatedWords[i] + ")",
                "",
                linkParams,
                true,
                true)%>
           </li>
<%
        }
%>
   </ul>
</center>

UrlUtils.htmlFormHiddenFields(pRequest,UrlUtils.PAGE_LINK, formName);
UrlUtils.htmlFormHiddenFields(someURL);

<INPUT TYPE="hidden" name="paramName" value="paramValue">

formTarget = UrlUtils.htmlFormActionLink(pRequest,UrlUtils.PAGE_LINK)

<%
    String paramNameSubmit = "submit";
    String paramNameQ = "q";
    String qualParamNameQ =
        HttpPortletRendererUtil.portletParameter(paramNameQ);
    String qualParamNameSubmit = 
    HttpPortletRendererUtil.portletParameter(paramNameSubmit);
    PortletRenderRequest pRequest = (PortletRenderRequest)
        request.getAttribute(HttpCommonConstants.PORTLET_RENDER_REQUEST);
    String formName = UrlUtils.htmlFormName(pRequest,"query_form");
%>
<!-- Output the HTML content -->
<center>
    <b>Thesaurus</b>
    Enter the word you want to search for
    <form name="<%= formName %>" method="POST" 
        action="<%= UrlUtils.htmlFormActionLink(pRequest,UrlUtils.PAGE_LINK) %>"> 
        <%= UrlUtils.htmlFormHiddenFields(pRequest,UrlUtils.PAGE_LINK, formName)%> 
        <table><tr><td>
            Word of interest:
        </td><td>
            <input
                type="text"
                size="20"
                name="<%= qualParamNameQ %>"
                value="">
        </td></tr></table>
        <input type=submit name="<%= qualParamNameSubmit %>" Value="Search">
    </form>
</center>

<portlet>
    <id>11</id> 
    <name>Multipage</name> 
    <title>MultiPage Sample</title> 
    <shortTitle>MultiPage</shortTitle> 
    <description>
        This portlet depicts switching between two screens all 
        in an application page.
    </description> 
    <timeout>40</timeout> 
    <timeoutMessage>MultiPage Sample timed out</timeoutMessage> 
    <renderer class="oracle.portal.provider.v2.render.RenderManager">
        <contentType>text/html</contentType> 
        <showPage>/htdocs/multipage/first.jsp</showPage> 
        <pageParameterName>next_page</pageParameterName> 
    </renderer>
</portlet>

<%
    PortletRenderRequest pRequest = (PortletRenderRequest)
        request.getAttribute(HttpCommonConstants.PORTLET_RENDER_REQUEST);
    String paramNameSubmit = "submit";
    String paramNameQ = "q";
    String qualParamNameQ =
        HttpPortletRendererUtil.portletParameter(pRequest, paramNameQ);
    String qualParamNameSubmit = 
    HttpPortletRendererUtil.portletParameter(pRequest, paramNameSubmit);
    String formName = UrlUtils.htmlFormName(pRequest,"query_form");
%>
<!-- Output the HTML content -->
<center>
    <b>Thesaurus</b>
    Enter the word you want to search for
    <form name="<%= formName %>" method="POST" 
        action="<%= UrlUtils.htmlFormActionLink(pRequest,UrlUtils.PAGE_LINK) %>"> 
        <%= UrlUtils.htmlFormHiddenFields(pRequest,UrlUtils.PAGE_LINK, formName)
%> 
        <%= UrlUtils.emitHiddenField(
                HttpPortletRendererUtil.portletParameter(request, "next_page"),
                "htdocs/path/ThesaurusLink.jsp" ) %>
        <table><tr><td>
            Word of interest:
        </td><td>
            <input
                type="text"
                size="20"
                name="<%= qualParamNameQ %>"
                value="">
        </td></tr></table>
        <input type=submit name="<%= qualParamNameSubmit %>" Value="Search">
    </form>
</center>

<%
    PortletRenderRequest pRequest = (PortletRenderRequest)
        request.getAttribute(HttpCommonConstants.PORTLET_RENDER_REQUEST);
    String paramNameQ = "q";
    String paramNameNextPage = "next_page";
    String qualParamNameQ = 
    HttpPortletRendererUtil.portletParameter(pRequest, paramNameQ);
    String qualParamNameNextPage = 
        HttpPortletRendererUtil.portletParameter(pRequest, paramNameNextPage);
    String paramValueQ = pRequest.getQualifiedParameter(paramNameQ);
%>
<!-- Output the HTML content -->
<center>
    Words similar to <%= paramValueQ %>
    <br>
    Click the link to search for words related to that word.
    <br>
    <ul>
<%
        Thesaurus t = new Thesaurus();
        String[] relatedWords = t.getRelatedWords(paramValueQ);
        NameValue[] linkParams = new NameValue[2]; 
        linkParams[0] = new NameValue(
            qualParamNameNextPage, "htdocs/path/ThesaurusLink.jsp");
        for (int i=0; i<relatedWords.length; i++)
        {
            linkParams[1] = new NameValue(
                qualParamNameQ, relatedWords[i]);
%>
            <li>
            <b> <%= relatedWords[i] %> </b>
            <%= UrlUtils.constructHTMLLink(
                pRequest,
                UrlUtils.PAGE_LINK,
                "(words related to " + relatedWords[i] + ")",
                "",
                linkParams,
                true,
                true)%>
           </li>
<%
        }
%>
   </ul>
   <a href="<%=XMLUtil.escapeXMLAttribute
               (pRequest.getRenderContext().getPageURL())%>">
      Reset Portlet
   </a>
</center>

<portlet class="oracle.portal.provider.v2.DefaultPortletDefinition">
   <id>1</id>
   <name>Multipage</name>
   <title>A MultiPage Portlet</title>
   ...
   <renderer class="oracle.portal.provider.v2.render.RenderManager">
          <contentType>text/html</contentType>
          <showPage>/htdocs/multiportlet/controller.jsp</showPage>
          <pageParameterName>show_page</pageParameterName>
          <allowedPath>/htdocs/multiportlet/*</allowedPath>
   </renderer>
</portlet>

30.2.4 How to Use JNDI Variables

When writing Java portlets, you may set deployment specific properties through the JNDI service such that their values may be retrieved from your producer code. In this way, you can specify any property in a producer deployment and then easily access it anywhere in your producer code.

You can use JNDI variables to change producer property values after the producer has been deployed. The environment entry must be declared in web.xml. It can then be updated on deployment using a deployment plan.

PDK-Java provides utilities to enable the retrieval of both producer and non-producer JNDI variables within a Java EE container.

<env-entry>
    <env-entry-name>variableName</env-entry-name>
    <env-entry-type>variableType</env-entry-type>
    <env-entry-value>variableValue</env-entry-value> 
</env-entry>

oracle/portal/myOtherProperty

String myVarName = "oracle/portal/myProvider/myVar"
String myVar = null;
try 
{
   InitialContext ic = new InitialContext();
   myVar = (String)ic.lookup("java:env/" + myVarName);
}
catch(NamingException ne)
{
   exception handling logic
}

oracle/portal/provider_service_name/variable_name
oracle/portal/variable_name

EnvLookup el = new EnvLookup();
String s = (String)el.lookup(myProviderName, myVariableName);

EnvLookup el = new EnvLookup();Object o = el.lookup(myVariableName);

oracle/portal/provider/provider_name/autoReload

oracle/portal/provider/provider_name/definition

oracle/portal/provider/global/log/logLevel

oracle/portal/provider/provider_name/maxTimeDifference

oracle/portal/provider/<service_name>/resourceUrlKey

oracle/portal/provider/provider_name/rootDirectory

oracle/portal/provider/provider_name/sharedKey

oracle/portal/provider/provider_name/showTestPage

oracle/portal/provider/global/transportEnabled

30.2.5 How to Access Session Information

When a user accesses a page, it initiates a public, unauthenticated session and tracks information about the session across requests. If the user logs in, then this session becomes an authenticated session of the logged-in user. This session terminates when any of the following occur:

• The browser session terminates (that is, the user closes all the browser windows).

• The user explicitly logs out.

• The session times out because the user's idle time exceeds the configured limit.

As part of the metadata generation, all of the producers that contribute portlets to the page are contacted, if they specified during registration that they be called for some special processing. This call allows producers to do processing based on the user session, log the user in the producer's application if needed, and establish producer sessions. For producers, this call is referred to as initSession. As most Web-enabled applications track sessions using cookies, this API call enables the producer of the application to return cookies.

You can use the session store to save and retrieve information that persists during the portal session. This information is only available, and useful, to you during the life of the session. You should store only temporary information in the session store. Application developers may use the session store to save information related to the current user session. Data in the session store can be shared across portlets.

If the information you want to store must persist across sessions, then you may want to store it in the preference store instead. Some common applications of the session store are as follows:

• To cache data that is expensive to load or calculate (for example, search results).

• To cache the current state of a portlet (for example, the current range, or page, of search results displayed in the portlet, or sequence of events performed by user).

Before you implement session storage, you should carefully consider the performance costs. Because portlets and producers are remote, it can be a relatively expensive operation to create and maintain even a small amount of information in the session store. For this reason, you may want to avoid altogether any session storage for public pages that are accessed frequently by many users.

Furthermore, while using the session store with producers, you create a stateful application that tracks state information in memory. Similarly, you create a stateful application if you use the file-system implementation of preference store.

If scalability is an important concern for you, then a stateful application may cause you problems. Stateful applications can affect the load-balancing and failover mechanism for your configuration. Even though you may deploy multiple middle-tiers, you must implement sticky routing (where the same node handles subsequent requests in the same session) to track state. Sticky routing may result in lopsided load-balancing or loss of session data in case a node crashes, affecting failover. This issue is one reason why many developers prefer to build stateless applications. However, if scalability is not a concern, then a stateful application should present no problems for you.

In the example in this section, session storage is used to count the number of times your portlet has rendered in Shared Screen mode.

Before You Begin

The steps that follow assume that you have:

• Followed through and understood Section 29.2.3, "How to Create a PDK-Java Portlet."

• Built a portlet using the wizard and successfully added it to a page.

30.2.5.1 Implementing Session Storage

The PDK Framework represents the session with a ProviderSession object, which is established during the call to the Provider Instance's initSession method. This object is associated with the ProviderUser. To make data persistent between requests, you must write data into the session object using the setAttribute method on the ProviderSession object. This method maps a java.lang.Object to a java.lang.String and stores that mapping inside the session object. The String can then be used to retrieve the Object during a subsequent request, provided the session is still valid.

A producer session may become invalid for the following reasons:

• The session times out.

• The invalidate method on ProviderSession is called.

• The JVM process running the servlet container is terminated.

All portlets contained by the same ProviderInstance share the same session for a particular ProviderUser. Therefore, data unique to a particular portlet instance must be mapped to a unique String in the session. This is accomplished using the portletParameter method in the PortletRendererUtil class. This method makes a supplied String parameter or attribute name unique to a PortletInstance, by prefixing it with a generated identifier for that instance. You can use the returned instance-specific name to write portlet instance data into the session.

For more detailed information about the PDK Framework classes, see the JavaDoc on OTN:

http://www.oracle.com/technology/products/webcenter/portlet_download.html

To implement session storage:

• Import ProviderSession, PortletRendererUtil, and HttpPortletRendererUtil.

• Retrieve the producer session.

• Read and write the session by accessing it from within your Java portlet.

• Set the session to true in provider.xml.

• Register the producer for session storage and set the Login Frequency.

The steps that follow describe how to add a session count to your portlet that displays how many times the portlet has been rendered for the current session.

1. After using the wizard to create a portlet, you can edit the JSP for the Show page in Oracle JDeveloper. You must import the following classes:

   <%@page contentType="text/html; charset=windows-1252"
   import="oracle.portal.provider.v2.render.PortletRenderRequest"
   import="oracle.portal.provider.v2.http.HttpCommonConstants"
   import="oracle.portal.provider.v2.ProviderSession"
   import="oracle.portal.provider.v2.render.PortletRendererUtil"
   import="oracle.portal.provider.v2.render.http.HttpPortletRendererUtil"
   %>
   

2. Insert code that checks for a valid session first and then increments the count and displays it. If the session is valid and a previously stored value exists, then you display the value, increment the count, and store the new value. If the session is valid but no previously stored value exists, then you initialize a new count starting with 1, and display and store the value. You also want to obtain the unique string key for this portlet and then use an it in an array to count the session. If no session information was received, then you want to provide information to the user indicating they may need to log back in.

   <%
   PortletRenderRequest pReq = (PortletRenderRequest)
   request.getAttribute(HttpCommonConstants.PORTLET_RENDER_REQUEST);
   ProviderSession pSession = pReq.getSession();
     if (pSession != null)
     {
       String key = PortletRendererUtil.portletParameter(pReq, "count");
       Integer i = (Integer)pSession.getAttribute(key);
       if (i == null)
       {
         i = new Integer(0);
       }
       i = new Integer(i.intValue()+1);
       pSession.setAttribute(key, i);
   %>
   
   <p>Render count in this session: <%=i%> </p>
   
   <% 
     } 
     else 
     {
   %>
   
   <p>The session has become invalid</p>
   <br>
   Please log out and log in again.
   <%
     } 
   %>
   

3. By default, the wizard does not set session to true in provider.xml. You must update this flag in order for the producer to receive session information from the portal. You should only set this tag to true if you are using session information in your producer or portlets. By setting this flag to true, extra load is added to the producer calls.

   <provider class="oracle.portal.provider.v2.DefaultProviderDefinition">
   <session>true</session>
   

   
   

   For more information about the syntax of provider.xml, see the provider JavaDoc on OTN:

   http://www.oracle.com/technology/products/webcenter/portlet_download.html

4. Register your producer with session support. For a reminder on how to register your portlet, see Section 33.4, "Registering and Viewing Your Portlet."

30.2.6 How to Enhance Portlet Performance with Caching

In the previous sections of this chapter, you learned how to write fully functional Java portlets using the PDK Framework. Once you complete the basic functionality of your portlet, you may want to turn your attention to portlet performance.

Caching is a common technique for enhancing the performance of Web sites that include a great deal of dynamic content. The overhead involved in retrieving data and generating the output for dynamic content can be significantly reduced by proxying requests through a local agent backed by a large, low-latency data store known as a cache. The cache agent responds to a request in one of two ways, as follows:

• If a valid version of the requested content exists in the cache, then the agent simply returns the existing cached copy, thus skipping the costly process of content retrieval and generation. This condition is called a cache hit.

• If a valid version of the requested content does not exist in the cache, then the agent forwards the request to its destination and awaits the return of the content. The agent returns the content to the requester and stores a local copy in its cache for reuse if a subsequent request for the same content arises. This condition is called a cache miss.

Producers generate dynamic content (that is, portlets) and they reside remotely from the custom WebCenter application instance on which they are deployed. As such, caching might improve their performance. The architecture lends itself well to caching. You can cache the portlets rendered by your producer and reuse the cached copies to handle subsequent requests, minimizing the overhead your producer imposes on page assembly.

The producer can use any one of three different caching methods, depending upon which one is best suited to the application. The methods differ chiefly in how they determine whether content is still valid. Following are the three caching methods:

• Expiry-based Caching: When a producer receives a render request, it stamps its response with an expiry time. The rendered response remains in the cache and fills all subsequent requests for the same content until its expiry time passes. This caching scheme is perhaps the simplest and most performant because the test for cache validity requires very little overhead and does not involve any network round trips. Expiry-based caching suits applications where the content has a well-defined life span. For content with a less certain life span, however, expiry-based caching is less effective. For more information, see Section 30.2.6.1, "Activating Caching" and Section 30.2.6.2, "Adding Expiry-Based Caching."

• Validation-based Caching: When a producer receives a render request, it stamps its response with a version identifier (or E Tag). The response goes into the cache, but, before the PPE can reuse the cached response, it must determine whether the cached version is still valid. It sends the producer a render request that includes the version identifier of the cached content. The producer determines whether the version identifier remains valid. If the version identifier is still valid, then the producer immediately sends a lightweight response to the PPE without any content, which indicates the cached version can be used. Otherwise, the producer generates new content with a new version identifier, which replaces the previously cached version. In this form of caching, the PPE must always confirm with the producer whether the content is up to date. The validity of the cached copy is determined by some logic in the producer. The advantage of this approach is that the producer controls the use of the cached content rather than relying on a fixed period. For more information, see Section 30.2.6.1, "Activating Caching" and Section 30.2.6.3, "Adding Validation-Based Caching."

Before You Begin

The steps that follow assume that you have:

• Followed through and understood Section 29.2.3, "How to Create a PDK-Java Portlet."

• Built a portlet using the wizard and successfully added it to a page.

public boolean prepareResponse(PortletRenderRequest pr)
                        throws PortletException,
                               PortletNotFoundException

30.4.1 Creating a Struts Portlet

Oracle PDK contains extensions to integrate Apache Struts applications. This section explains how to build a portlet from an existing struts application. You can also follow these steps to create a portlet that uses the Model View Controller paradigm. The PDK-Java extensions described in this section rely on Apache Struts 1.1.

The Oracle PDK-Java contains numerous examples and documents regarding the usage of the APIs, such as personalization and caching. The integration of the application flow and business logic is not part of the portlet APIs. By using the Struts framework, however, you can leverage the MVC architecture to create and publish applications within your enterprise portal.

To create a portlet using the Struts framework, or to generate a portlet from an existing Struts application, you must deploy all the components in the Java EE container. In WebCenter, the Struts application is called by the PPE, and not by the browser as compared to a standalone Struts application. When a portlet show call is made, the page engine sends a request to the Struts portlet renderer, which then forwards the request to the Apache Struts Controller servlet, as shown in Figure 30-4.

Figure 30-4 Integrating Struts Applications with Oracle Portal

Description of "Figure 30-4 Integrating Struts Applications with Oracle Portal"

The following code shows a portion of the producer definition file (provider.xml):

...
<renderContainer>true</renderContainer>
    <renderCustomize>true</renderCustomize>
    <autoRedirect>true</autoRedirect>
    <contentType>text/html</contentType>
    <showPage class="oracle.portal.provider.v2.render.http.StrutsRenderer">
        <defaultAction>showCustomer.do</defaultAction>
    </showPage>
</renderer>
...

For more information about the syntax of provider.xml, see the provider JavaDoc on OTN:

http://www.oracle.com/technology/products/webcenter/portlet_download.html

The showPage tag defines the business logic that is executed in the portlet mode of the portlet. The showPage of the Struts portlet contains two important components, which are as follows:

• The renderer class (oracle.portal.provider.v2.render.http.StrutsRenderer), which receives the portlet request from the PPE and acts as a proxy to forward the request to the Struts Action Servlet.

• The defaultAction tag, which defines the Struts action that is used by default when the portlet is called for the first time.

The PDK-Java enables you to easily develop a view (Portal View) of your Struts application. This view enforces a consistent look and feel of your Struts portlet using portal styles, and enables the end user to use the application within the portal.

To create a Struts portlet, you must use the Oracle Portal JSP tags, which are extensions of the default Struts JSP tags. This development process is similar to that of creating a standalone Struts application. Also, as the portlet and struts application must also be in the same Servlet Context, you must create a single Web application that contains both elements.

To publish a part of an existing Struts application as a portlet, Oracle recommends that you first create a new view to serve as the Portal View of your application. This view uses existing objects (Actions, ActionForm, and so on) with a new mapping and new JSPs.

In this example, you will create a portlet that enables you to add a new entry to a blog. Figure 30-5 and Figure 30-6 show how you submit a blog and save a blog entry.

Figure 30-5 Submitting a Blog

Description of "Figure 30-5 Submitting a Blog"

Figure 30-6 Saving a Blog Entry

Description of "Figure 30-6 Saving a Blog Entry"

prepareNewBlog is a simple empty action that redirects the request to the enterNewBlog.jsp page. This page shows a form for submitting a new blog.

The corresponding entry in the struts-config.xml is:

<action path="/prepareNewBlog" scope="request"
    type="view.PrepareNewBlogAction" >
    <forward name="success" path="/view/enterNewBlog.jsp"/>
</action>
<action path="/saveNewBlog" name="blogForm" scope="request"
    type="view.SaveNewBlogAction" input"/view/enterNewBlog.jsp"  >
    <forward name="success" path="/view/newBlogConfirmation.jsp"/>
</action>

<action path="/portal/prepareNewBlog" scope="request"
    type="view.PrepareNewBlogAction" >
    <forward name="success" path="/view/portal/enterNewBlog.jsp"/>
</action>
<action path="/portal/saveNewBlog" name="blogForm" scope="request"
    type="view.SaveNewBlogAction" input="/view/enterNewBlog.jsp"  >
    <forward name="success" path="/view/portal/newBlogConfirmation.jsp"/>
</action>

<pdk-struts-html:form action="/portal/saveNewBlog.do">
...
...
</pdk-struts-html:form>