Introduction to Portals

What is a Portal?

A portal represents a web site that provides a single point of access to applications and information. From an end user perspective, a portal is a web site with pages that are organized by tabs or some other form of navigation. A portal represents a web site that provides a single point of access to applications and information. A page can contain multiple portlets, giving users access to different information. Users can also customize their view of a portal by adding their own pages, adding portlets of their choosing, and changing the Look And Feel of the interface. 

Technically speaking, a portal is a container of resources and functionality that can be made available to end users. These portal views, which are called desktops in WebLogic Portal, provide the uniform resource location (URL) that users access. Portal administrators and users can customize portals, and content can be presented based on user preferences or rule-based personalization. Each portal is associated with a web application that contains all of the resources required to run portals on the web. 

Every one have the common doubt like how the portal will be look like? So the given figure is the example for portal.

Portals provide the following benefits to the user: 

Aggregation – The user can go to a single place for all content and applications. 

Customization – The preferences for a user determine how the portal looks and feels. 

Personalization – The user can obtain content that is specific to their interests and needs. 

Organization – The user can arrange the content and applications to make better sense of the information. 

Integration – The user can work with multiple applications and content sources in a unified fashion. 

Portals typically include the following features and benefits:

 Search – Enterprise and web-based search facilities 

 Content Management – Creation, management, and delivery of content 

 Content Repurposing – Including content from multiple disparate data           sources 

 Portals optionally include the following features and benefits:

• Workflow – Business process management
• Single Sign-On – Allows users to log on once for all applications within the portal

 After you create the parts of a portal using Workshop for WebLogic, you assemble it into a desktop using the WebLogic Portal Administration Console. From an administrative standpoint, a portal is a container that defines a portal application. When you create a new portal using the Administration Console, you are really creating an empty portal to hold different versions of the portal (desktops) that can be targeted to specific users. A portal can contain one or more desktops, or views, of a portal. It is the desktops to which you add the portal resources and navigation such as books, pages, and portlets that make a dynamic portal. 

Each portal is associated with a web application that contains all of the resources required to run portals on the web.

 

Contents for Portal Development Guide

Introduction to Portals
What is a Portal?
What is the Portal Framework?
Portal Development and the Portal Life Cycle
Architecture
Development
Staging
Production
Getting Started
Prerequisites
Related Guides
Part I Architecture
Planning Your Portal
Production Operations (Propagation and Deployment)
Portal Development in a Distributed Portal Team
Federated Portals
Security
Content Management
Interaction Management
Performance
Portals and Mobile Devices
Part II Development
Understanding Portal Development
Portal Components
Portal Component Hierarchy
Portal Development Environment in Workshop for WebLogic
WebLogic Portal and Shared J2EE Libraries
File-Based Portals and Streaming Portals
Java Controls in Portals
JSP Tags in Portals
Asynchronous Rendering
Backing Files
How Backing Files are Executed
Thread Safety and Backing Files
Scoping and Backing Files
Using the Session to Pass Data Between Life Cycle Methods
Backing File Guidelines

Adding a Backing File Using Workshop for WebLogic

Adding the Backing File by Editing the XML File
Page Flows in Portals
State/Session Management
HTTP Session Sharing
Setting up Your Portal Development Environment
Roadmap for Environment Setup Tasks
Portal Perspective
WebLogic Domain Configuration Wizard
Portal EAR Project Wizard
New Portal EAR Project – Select Project Facets Dialog
Add and Remove Projects Dialog
Portal Web Project Wizard
New Portal Web Project – Portal Web Project
New Portal Web Project – Select Project Facets dialog
New Portal Web Project - Web Module Dialog
New Portal Web Project - WebLogic Web Module Dialog
Portal Datasync Project Wizard
Create New Datasync Project – EAR Projects
Associating Web and Datasync Projects with EAR Projects
Associating an Web Project with an EAR Project
Associating an Datasync Project with an EAR Project
Using the Merged Projects View
Opening the Merged Projects View
Working with the Merged Projects View
Running a Project on the Server
Stopping the Server
Customizing a Perspective
Setting WebLogic Portal Preferences in Workshop for WebLogic
Preferences in the WebLogic Portal Section
WebLogic Portal Preferences in the General Section
Integrating Applications into WebLogic Portal
Integrating an Existing Web Application into Workshop for WebLogic
Integrating Struts Applications
Preparing Your Struts Application for Integration

Refactor

Add Tags if Needed

Override Certain Behaviors of a RequestProcessor

Refactor any Existing Custom Action Servlet

Remove the <html:link> Tag
Integration Steps
Best Practices and Development Issues
Integrating Java Server Faces
JSF and the namingContainer JSP Tag
Integrating Page Flows
Adding Facets to an Existing Project
Other Methods of Integrating an External Web Application into a Portal
User Interface Development with Look And Feel Features
Look And Feel Framework Overview
Working with Look And Feel Files
Defining a Look And Feel for a Desktop
Customizing Look and Feels
Combining Skins and Skeletons in a New Look And Feel
Defining Titlebar Buttons and Window Icons
Modifying CSS Files
Working with Genes and Chromosomes

Gene Example

Creating a Chromosome and Genes

Using the Look And Feel Editor with Genes
Creating a New Look and Feel
Working with Skins

Best Practices

Considerations for Microsoft Internet Explorer

About Portlet Title Bar Icons
Working with Skeletons

What is a Skeleton?

Guidelines for Creating Custom Skeletons

Enabling XHTML in a Portal
Working with Themes
Using Themes with Microsoft Internet Explorer
Developing a Theme
Using Look And Feels From Previous Portal Releases
Troubleshooting Look And Feels
The Look And Feel Editor
Overview
The Look and Feel Editor Window
Opening the Look And Feel Editor
Style Hierarchy Tab
Style Description Panel

CSS Inheritance

Using the Inherited Styles List
View Area
Outline View
Properties View
Tips for Using the Look and Feel Editor

Using the Link Style Hiearchy Selection with HTML Preview Selection Button

Enabling the Mouse Motion Button
Look And Feel API
Working with Shells
Creating a New Shell
Modifying a Shell
Applying a Shell to a Portal Desktop
Placing Portlets in a Header or Footer
Working with Layouts
Creating a Standard Layout
Creating a Custom Layout

The Layout File

Example of a Custom Layout

The Skeleton JSP

The html.txt File
Working with Navigation Menus

Using Images for Page Tabs
Building User Interfaces to Address Accessibility Guidelines
Accessibility Checkpoints
W3C Web Content Accessibility Guidelines
Government Regulations and Standards
Accessibility Evaluation and Testing Tools

W3C Web Accessibility Initiative

Lynx Viewer
Developing Portals Using Workshop for WebLogic
Creating a Portal
Add a Page or Book to Your Portal
Creating a Standalone Book or Page
Extracting an Existing Page or Book to Re-Use
Adding a Book or Page Reference (Content)

Adding a Book or Page Reference from the Portal Editor

Adding a Book or Page Reference Using the Outline View
Rearranging Books and Pages
Setting Portal Component Properties
Editing Portal Properties
Tips for Using the Properties View

Presentation Properties

Desktop Properties

Book Properties

Page Properties

Placeholder Properties
Copying J2EE Library Files into a Project
Viewing Files that Override Shared J2EE Library Files
Custom Controls in Page Flows
Adding a Portal Control to a Page Flow
Adding an Action to the Page Flow
Portal Control Security
Deploy and View a Portal
Working with URLs
Creating URLs to Portal Resources
URL Compression

Implementing URL Compression

URL Compression Special Considerations

URL Compression and AJAX

URL Compression and Off-Site URLs

URL Compression and Frequently-Accessed Data
URL Troubleshooting

URL Templates and Web Services for Remote Portlets (WSRP)
Ampersand Entities in Portal URLs
Optional Look And Feel URL Templates
Working with Encoding in HTTP Responses
Cache Management in Workshop for WebLogic
Changing Cache Settings in Workshop for WebLogic
Improving WebLogic Server Administration Console Performance on a Managed Server
Behavior of the “Return to Default Page” Attribute
Adding Commerce Services to an Existing Portal Web Project
Customizing Problem Validation Settings
Enabling/Disabling WebLogic Portal Validation

Enabling/Disabling Validation Globally

Enabling/Disabling Validation Per Project
Customizing WebLogic Portal Validation Mappings

Overview

Customizing Validation Globally

Customizing Validation Per Project
Enabling Placeable Movement
Configuring the Portal in Workshop for WebLogic
Setting Up a Desktop in the Administration Console
Testing Placeable Movement
Enabling Placeable Movement for an Existing Desktop
Limitations
Using Placeable Movement with Custom Layouts
Introduction
Before You Begin
Rules for Using Placeable Movement with Custom Layouts
Sample Code
Localizing Titles for File-Based Books, Pages, and Portlets
Enabling Visitor Tools
What Are Visitor Tools?
Enabling Visitor Tools
Verifying the Portal Visitor Tools Facet
Enabling Visitor Tools for a Desktop
Creating Portals for Multiple Device Types
Enabling Multichannel Features in a Portal Web Application
Roadmap for Multichannel Processing
Developing Portals for Use in a Multichannel Environment
Manage Portlet Client Classifications
Use the Client Attribute in JSP Tags
Develop Appropriate Look And Feels
Interaction Management Development
Designing Portals for Optimal Performance
Asynchronous Desktop Rendering
Choosing the Method of Asynchronous Rendering
Configuring Asynchronous Desktop Rendering
Control Tree Design
How the Control Tree Works
How the Control Tree Affects Performance
Using Multiple Desktops
Why This is a Good Idea
Design Decisions for Using Multiple Desktops
Optimizing the Control Tree
Enabling Control Tree Optimization

Setting the Current Page
How Tree Optimization Works
Multi Level Menus and Control Tree Optimization
Limitations to Using Tree Optimization
Disabling Tree Optimization
Other Ways to Improve Performance
Use Entitlements Judiciously

How Entitlements Affect Performance

Recommendations for Using Entitlements
Limit User Customizations
Optimize Page Flow Session Footprint
Use File-Based Portals for Simple Applications

Why Use a File-based Portal?

Limitations to Using File-based Portals
Create a Production Domain in Development
Optimize Portlet Performance
Obtaining Debug Information
Introduction
Configuring and Enabling Debug
Using Debug in Your WLP Code
Turning Debug Output On and Off
Package-Level Debugging
Directing Output to a File
Reloading Debug Properties
Example debug.properties File
Public WLP Class Debug Reference
WLP Framework Classes with Debug Support
WLP Core Services Classes with Debug Support
WLP Virtual Content Repository Classes with Debug Support
WLP UCM Classes with Debug Support
WLP Administration Console Classes with Debug Support
Part III Staging
Managing Portal Desktops
Administration Console Overview
Administration Console Library of Resources
Starting and Logging In to the Administration Console
Opening the Administration Console
Logging In to the Administration Console
Overview of Library Administration
Overview of Portal Administration
Portal Management
Overview of the Library
Desktop Templates
Creating a Desktop Template
Communities
Portal Resources
Updating Portal Resources
Viewing Resources for a Portal Web Application (Update WebApp)
Deleting a Portal Resource
Localizing a Portal Resource
Portals
Creating a Portal
Modifying Portal Properties
Desktops
Creating a Desktop

Disassembling to the Library

Decoupling of Property Settings
Modifying Desktop Properties
Books
Creating a Book
Managing Book Content

Adding Portal Elements to a Book

Positioning or Removing Portal Elements on a Book
Modifying Library Book Properties and Contents
Modifying Desktop Book Properties
Pages
Creating a New Page
Managing Page Content

Adding Contents to a Page

Positioning Elements on a Page
Modifying Library Page Properties
Modifying Desktop Page Properties
Moving a Page or Book to Another Location on the Desktop
Portlets
Copying a Portlet in the Library
Deleting a Portlet
Modifying Library Portlet Properties
Modifying Desktop Portlet Properties
Portlet Preferences
Creating a Portlet Preference
Editing a Portlet Preference
Portlet Categories
Creating a Portlet Category
Adding Portlets to a Portlet Category
Modifying Portlet Category Properties
Look And Feels
Modifying Look And Feel Properties
Shells
Modifying Shell Properties
Themes
Modifying Theme Properties
Menus (Navigation)
Modifying Menu Properties
Layouts
Modifying Layout Properties
Deploying Portals to Production
Shared J2EE Libraries
Shared J2EE Library References in config.xml

Anatomy of a Shared J2EE Library
Overriding Shared J2EE Library Settings in the web.xml File

Servlet Mapping Overrides
Part IV Production
Managing Portals in Production
Pushing Changes from the Library into Production
Transferring Changes from Production Back to Development
Facet-to-Library Reference Tables
WebLogic Portal Facet-to-Library