| products | dev2dev | support | askBEA
 Download Docs   Site Map   Glossary 

Development Guide

 Previous Next Contents Index View as PDF  

Introduction to WebLogic Portal Development

A Developer's Portal Primer

Portal Features

Personalization and Authorization

Group Portals

JSPs and JSP tags


Unified User Profile

Other Useful Features

Portal Component File Locations

Roadmap for Building a Portal

How do I Build a Portal?

How Can I Extend these Portals?

How Do I Get Started?


Part I. Developing Portals - Tutorials

Creating a New Portal in a New Domain

Step 1: Create the New Domain

Step 2: Create the New Portal

Step 3: Add a Portlet

Step 4: Make New Portlet Visible

Adding Portal to an Existing Domain

About Your Domain

Before You Begin

Preserve or Replace the Existing Domain

Procedure A

Procedure B

Use or Replace Existing Database

Procedure C

Procedure D

Locate or Install Enterprise Application

Procedure E

Procedure F

Deploying Portals

Hot Deploying With the Portal Wizard

Deploying Without the Portal Wizard

Deploying a Portal without Hot Deploy

Manually Deploying a Portal Web Application

Step 1: Move J2EE Resources

Step 2: Synchronize Metadata

Step 3: Deploy in the WebLogic Server Console

Best Practice Guidelines for Deploying Your Portal

Stage 1: Deploy to a Server on Your Own Machine

Stage 2: Deploy From a Local Computer to a Staging Server

Stage 3: Deploy From the Testing Environment to a Live Production Server


Part II. Extending Portals

Building Custom Templates

Introducing Templates

Three Types of Templates

The Domain Wizard Template

The Portal Wizard Template

The Group Portal Template

Using Templates

Creating a Domain Template

Step 1: Instantiate a Portal Domain

Step 2: Customize the Portal Domain

Supporting Two-Phase Deployment

Adding All Portal Services to Your Domain

Adding an EJB to your WebLogic Portal Domain

Step 3: Apply General Configuration

Adding a Custom Layout to a Domain Template

Adding a Custom Skin to a Domain Template

Step 4: Package the New Domain as a Template

Open the template.xml File

Edit the config.xml file

Edit the Application.xml file

Check Shell Scripts for String Substitution

Create the Archive

Creating a Portal Template

Instantiate a New Portal

Customize the New Portal

Apply Basic Configuration

Package the New Portal as a Template

Step 1: Make Staging Directory

Step 2: Locate Source Directories

Step 3: Move Portal Resources

Step 4: Edit template.xml

Step 5: Create a Thumbnail

Step 6: Create Archive File

Step 7: Make the Archive Available

Implementing User Profiles

Creating a Unified User Profile

Create an EntityPropertyManager EJB to Represent External Data

Recommended EJB Guidelines

Deploy a ProfileManager That Can Use the New EntityPropertyManager

Modifying the Existing ProfileManager Deployment Configuration

Configuring and Deploying a New ProfileManager

Retrieving User Profile Data from LDAP

Creating a Property Set Definition

Registering Custom User Profiles

Properties with Boolean or a Single Value and Single Default

Properties with Multiple Values and Single, Multiple, or All Defaults

Properties with Date and Time Values

Updating a Registered Custom Event

Enabling Visitor Self-Registration

Implementing Customer Profile JSPs








Webflow Components Used in Visitor Self-Registration

Input Processors

Pipeline Components

Adding Security to a Portal

Implementing Portal Security

Integrating with an LDAP Security Realm

Supported LDAP Servers

Integrating an LDAP Security Realm

Configuring the LDAP Server for Integration

Configuring LDAP-based Security Realms for WebLogic Server and Portal 7.0

Supported Server Templates

Using Wildcards for User Lookup in an LDAP Realm

Adding User Profile Information to LDAP Users

Switching to a WebLogic 7.0 Security Framework Security Realm

Upgrading a Portal from Compatibility Security to WebLogic Server 7.0 Security With RDBMS

Core Groups required for WebLogic Portal

Running the WLP Samples

Upgrading a Portal from Compatibility Security to WebLogic Server 7.0 Security with Embedded LDAP

Upgrading a Portal from Compatibility Security to WebLogic Server 7.0 Security with a Commercial LDAP Provider

Multiple Authentication Providers Support in WebLogic Portal 7.0 SP4

How WebLogic Portal 7.0 uses the WebLogic Server Security Framework

Limited Support of Multiple Authentication Providers in WebLogic Portal 7.0 SP4

What Is Not Supported for Multiple Authentication Providers in WebLogic Portal 7.0 SP4

Other Supported Security Realms

Enabling Secure Sockets Layer Security

config.xml Requirements for SSL

web.xml Requirements for SSL


Enabling Single Sign-On

Setting the Cookie Name

Setting the User Properties

Portal Content Management

Adding Content by Using the Bulk Loader

BulkLoader Performance Tips

Configuring the Content Manager

Configuring the DocumentManager EJB Deployment Descriptor

Configuring the PropertySetManager EJB Deployment Descriptor for Content Management

Configuring DocumentManager MBeans

Using the WebLogic Server Administration Console to Modify DocumentManager MBeans

Disabling an MBean

Restoring a Disabled MBean

Setting Up Document Connection Pools

Editing a DocumentConnectionPool MBean in the WebLogic Console

Configuring the Web Application

Using Content-Selector Tags and Associated JSP Tags

Using the <pz:contentSelector> Tag

Identify the Content Selector Definition

Identify the JNDI Home for the Content Management System

Define the Array That Contains Query Results

Create and Configure the Cache to Improve Performance

Associated Tags That Support Content Selectors

Using Content Selector Tags and Associated Tags

Retrieving and Displaying Text-Type Documents

Retrieving and Displaying Image-Type Documents

Retrieving and Displaying a List of Documents

Accessing a Content Selector Cache on a Different JSP

Integrating External Content Management Systems

Integration Strategies

Adding Content by Implementing a DocumentProvider Interface

Step 1. Ensure that the CMS Meets the Minimum Use Requirements

Step 2. Write the SPI Implementation

Step 3. Place Code Into the Application

Step 4. Make the .jar Accessible to the Application

Step 5. Restart the Server

Step 6. Apply the Portal

Publishing to Reference Implementation

Constructing Content Queries

Structuring Queries

Using Comparison Operators to Construct Queries

Constructing Queries Using Java

Using the Document Servlet

Example 1: Usage in a JSP

Example 2: Usage in a JSP

Setting Up Portal Navigation

Building a Webflow

Understanding Webflow Components

Nodes and Transitions

Types of Nodes

Types of Transitions

Types of Events

Encoding Webflow URLs

Webflow Tools and Buttons

Step 1. Create the Webflow

Step 2. Add Nodes to the Webflow Canvas

Step 3. Identify the Begin Node

Step 4. Create Transitions Between Nodes

Adding an Event Transition

Adding an Exception Transition

Creating a Pipeline and Adding it to a Webflow

Understanding the Pipeline Editor

Step 1: Create a New Pipeline Component

Step 2: Add the New Pipeline Component to the Webflow

Synchronizing the Webflow to the Application

Creating a New Input Processor

Creating an Input Processor with the InputProcessor Interface

Naming an Input Processor

Executing Business Logic with Input Processors

Extending the InputProcessorSupport Class

Extending Webflow by Creating Extension Presentation and Processor Nodes

How to Create an Extension Presentation Node

How to Create an Extension Processor Node

Making Your Extension Presentation and Processor Nodes Available in the Webflow and Pipeline Editors

Registering an Extension Presentation Node

Registering an Extension Processor Node

Creating a Look-and-Feel

Portal Look-and-Feel Structure

Using Skins

Creating Skins

Skins Provided by BEA

Storing Skins

Making Skins Available

Using Layouts

Creating Layouts

Storing Layouts

Making Layouts Available

Extending Portlets

Basic Portlet Customization

Moving a Portlet Between Portal Web Applications

Step 1: Copy J2EE Resources into New Web Application

Step 2: Edit the Target Web Application Metadata

Step 3: Synchronize the Project

Step 4: Make the New Portlet Visible and Available

Moving a Portlet Between Domains

Creating Categories for Portlets

Preparing to Work With Categories

Creating Portlets and Categories

Moving Portlets and Categories

Adding Portlets to Existing Categories

Portlets and the Framework

Simple JSP Portlets

The scriptDemo Portlet

Calling ActiveX Components from a Portlet

WebFlow Portlets

Three Webflow Portlets

How a Portlet Handles a Refresh Event

Making a Portlet Respond to a Custom Event

Sharing State from One Portlet to Another

Web Service Portlets

Using the Portlet Wizard to Create Web Services Portlets

Creating a Simple Form-Driven Web Service Portlet

Creating a Call-Generation Web Service Portlet

Creating a Web Services Interface Portlet

Deploying the Web Services Portlets

Viewing the Web Services Portlets

Calling Web Services Asynchronously

Error Handling within Web Services Portlets

Portalizing an Existing Web Application

Getting Started


Process Overview

Step 1: Create a Portal Web Application

Step 2: Build a 2-page WebFlow Portlet

Step 3: Edit Portlet Code

Replace Portlet JSPs

Save Properties Fies for Internationalization

Step 4: Load Content Resources

Step 5: Test the application

Performance Tuning

Using Caches to Tune Performance

Adjust Caching for Content Management

Property Caching in a Clustered Environment

Adjust Caching for the Discount Service

Adjusting the discountCache

Adjusting the globalDiscountCache

Discount-Service Caches in Clustered and Non-Clustered Environments

Adjust Group Membership TTL in the Caching Realm

Tuning Thread / Connection Parameters in JDBC

Setting Up Personalization and Interaction Management

Using the Advisor to Personalize a Portal Application

Creating a Personalized Portal Application with Advisor JSP Tags

Classifying Users with the JSP <pz:div> Tag

Selecting Content with the <pz:contentQuery> JSP Tag

Matching Content to Users with the <pz:contentSelector> JSP Tag

Creating Personalized Applications with the Advisor Session Bean

Classifying Users with the Advisor Session Bean

Querying a Content Management System with  the  Advisor Session Bean

Matching Content to Users with the Advisor Session Bean

Personalizing Applications with HTTP Request and Session Properties

HTTP Request-Based Personalization

HTTP Session-Based Personalization

Special Considerations

Triggering Campaign Actions with Session, Request, and Event Properties

Working with the Rules Framework

Validating Rules Expressions

Rules Engine Error Handling and Reporting

Personalization with Content Selectors

Using an Edit .jsp to Personalize a Portlet

Step 1. Create the Edit JSP

Step 2. Enable Portlet Editing

Personalizing a Portal or Portlet by Using Placeholders

How Placeholders are Used

Placeholder JSP Tag: <ph:placeholder>


Implementing the Placeholder

Creating Placeholder Files

Setting Up Campaign Services

What are Campaign Services?

Building Placeholders for Campaigns

Using Attributes to Specify Display and Clickthrough Behavior

Loading Ads Into Your Content Management System

Loading Ads into the Reference Content Management System

Step 1. Set Up Attributes in HTML Documents

Step 2. Set Up Attribute Files for Image and Shockwave Documents

Step 3. Move Files Into the dmsBase/Ads Directory Tree

Step 4. Run the loadads Script

Creating Personalized E-mails for Campaigns

Step 1. Configure the E-mail Properties

Step 2. Find Names of User Properties

Step 3. Create E-mail JSPs

E-mail Parameters

Disabling Session Generation

Sample E-mail JSP

Saving E-Mail JSPs

Sending Bulk Mail

Sending Mail from a Remote Host or in a Clustered Environment

Modify the Send-Mail Script to Work from a Remote Host

Modify the Send-Mail Script to Work in a Clustered Environment

Sending Bulk E-mail

Scheduling Bulk E-mail Delivery

Deleting E-mail Batches

Setting Up Commerce Services

Integrating a Portal with Business Transaction Services

Integrating with a Taxation Service

If the Third-Party Vendor Hosts the Web Service

If Your Organization Hosts the Web Service

Integrating with a Payment Service

If the Third-Party Vendor Hosts the Web Service

Important Security Information

If Your Organization Hosts the Web Service

Guidelines for Modifying the Credit Card Web Service EJB

Supporting a Product Catalog

Loading Your Product Data Into the Product Catalog Database Schema

Step 1: Prepare to Use DBLoader

Step 2: Edit the File

Step 3: Load Data by Running the DBLoader Program

Step 4: Troubleshoot Using the DBLoader Log Files

Showing a Catalog in a JSP

Using the <catalog:getProperty> Tag

Using the <catalog:iterateViewIterator> Tag

Using the <catalog:iterateThroughView> Tag

Hooking Up a Catalog to a Shopping Cart

Implementing shoppingcart.jsp

How shoppingcart.jsp Works


Location in Default Webflow


How shoppingcart.jsp Displays Data

shoppingcart.jsp Form Fields

shoppingcart.jsp Input Processorss

shoppingcart.jsp Pipeline Components


Integrating Services With the Catalog Cache

Event and Behavior Tracking

How Events Work in Campaigns

How the Event Service Works

How Event Sequences Work

How to Use Standard Events

Servlet Lifecycle Events and Servlet Filter Events

Generating Login and Creation Events

Adding or Customizing Event Generators

Creating Custom Events

Writing the Custom Event Class

Writing the Custom Event Listener

Installing the Listener Class in the Event Service

Writing a Behavior Tracking Event Class

Configuring Events Buffer Sweeping

Facilitating OffLine Processing

Writing a TrackingEvent Base Class Constructor

How to Enable Behavior Tracking

Converting Behavior Tracking Events to XML

Creating Custom Behavior Tracking Event Listeners

Writing Custom Event Generators

Debugging the Event Service

Registering Custom Events

When to Register an Event

Event Properties

Instructions for Registering a Custom Event

Updating a Registered Custom Event

Activating Behavior Tracking

Procedure for Activating Behavior Tracking

Configuring the Behavior Tracking Service in WebLogic Server

Configuring a Data Source

Using the Expression Package

What Is the Expression Package?

Using Rules or Expressions

Expression Package Classes

The Package Structure for the Expression Package

Assembling and Managing Expressions

Maintaining Parent-child Relationships

Managing the Expression Cache

Working with Expressions

The Expression Factory

Expression Package Services

Unification Service

Optimization Service

Validation Service

Evaluation Service

Execution Service

Code Examples

Stateful Evaluation of a Simple Expression

Stateful Evaluation of an Expression Containing Variables

Stateless Validation and Evaluation of an Expression
Containing Variables

Stateful Validation and Evaluation of an Expression
Containing Variables

Configuring the Expression Package

Event Descriptions

Session Events

User Registration Event

Product Events

Content Events

Cart Events

Buy Event

Rules Event

Campaign Events


Back to Top Previous Next