|< Day Day Up >|| |
The following is from the WebSphere Portal Zone, available to IBMers at http://www7b.software.ibm.com/wsdd/zones/portal/roadmaps/develop.html.
Web development skills, including familiarity with HTML and XML
Basic Java programming concepts
Basic understanding of J2EE technology
J2EE technology and its component-based model simplifies enterprise development and deployment. The J2EE platform manages the infrastructure and supports the Web services requireed to enable the development of secure, robust, and interoperable business applications.
Servlets and IBM WebSphere Application Server
Know how to install, configure, and maintain IBM WebSphere Application Server Advanced Edition and to deploy enterprise Java applications in a single machine or clustered configurations.
WebSphere Application Server
Must be proficient in the foundation platform where WebSphere Portal runs. The following is from http://www7b.software.ibm.com/wsdd/zones/was/bigpicture.html:
WebSphere Application Server provides a rich, e-business application deployment environment with a complete set of application services, including capabilities for transaction management, security, clustering, performance, availability, connectivity, and scalability. WebSphere Application Server is a Java-based Web application server built on open standards that helps you deploy and manage applications ranging from simple Web sites to powerful e-business solutions. It is J2EE-compliant and provides a portable Web deployment platform for Java components, XML, and Web services that can interact with databases and provide dynamic Web content.
With the release of WebSphere Application Server Version 5, the IBM WebSphere Application Server family has evolved to a single, deployment-agile, Web services-enabled J2EE offering supported by complementary products such as an integrated development environment and an array of optional high-value platform solutions (such as portals, process management, and wireless). Whether you are just getting started or searching for a world-class application serving environment, WebSphere Application Server Version 5 has an answer with one of its flexible configurations for your e-business needs.
Before you can create portlets, you must prepare your development environment by installing WebSphere Portal. You can perform a standard production installation of one of the WebSphere Portal for Multiplatforms offerings, or you can perform a customized development installation for use with the Portal Toolkit.
Just as migration from one version of WebSphere Portal to another can require special attention, there are also considerations you must take into account when migrating portlets and portlet applications for use with a different version of WebSphere Portal.
To create a truly customized portal experience, you can create your own portlets and portlet applications.
Portlets are reusable components that provide access to Web-based content, applications, and other resources. Web pages, Web services, applications, and syndicated content feeds can be accessed through portlets. Companies can create their own portlets or select portlets from a catalog of third-party portlets. Portlets are intended to be assembled into a larger portal page, with multiple instances of the same portlet displaying different data for each user.
From a user's perspective, a portlet is a window on a portal site that provides a specific service or information (for example, a calendar or news feed). From an application development perspective, portlets are pluggable modules designed to run inside a portlet container of a portal server.
The portlet container provides a runtime environment in which portlets are instantiated, used, and finally destroyed. Portlets rely on the portal infrastructure to access user profile information, participate in window and action events, communicate with other portlets, access remote content, look up credentials, and store persistent data. The Portlet API provides standard interfaces for these functions. The portlet container is not a standalone container like the servlet container. Rather, it is implemented as a thin layer on top of the servlet container and reuses the functionality provided by that container.
IBM is working with other companies to standardize the Portlet API, making portlets interoperable between portal servers that implement the specification. The Portlet API offered in WebSphere Portal Version 4.1 is the first step toward the Portlet API standardization.
IBMers can go to http://publib.boulder.ibm.com/pvc/wp/42/exp/en/InfoCenter/wps/wpspapi.html for more information.
IBMers can go to http://publib.boulder.ibm.com/pvc/wp/42/exp/en/InfoCenter/wps/wpswrplt.html to learn about the following:
Creating a simple portlet instance
Setting up a portlet development environment
Compiling Java source
Packaging and deploying portlets
Message and trace logging
Refreshing the portlet cache
Parallel portlet rendering
Accessing the portlet session when the user is not authenticated
Analyzing portlet usage
Integrating advanced features with portlets
IBMers can go to http://publib.boulder.ibm.com/pvc/wp/42/exp/en/InfoCenter/wps/wpspar.html to learn about the following:
Model-View-Controller (MVC) design pattern
Portlet creation guidelines
Using Portlet API tags
IBMers can go to http://publib.boulder.ibm.com/pvc/wp/42/exp/en/InfoCenter/wps/wpsadvdev.html to learn about the following:
Using the credential vault
Credential vault samples
Using JAAS to retrieve the user's credentials
Lotus Software Collaborative Components provide Java API methods and tags for JavaServer Pages (JSPs) to extend the functionality of Lotus advanced collaboration in portlets. Collaborative Components are a set of methods and tags that allow developers who are writing portlets for WebSphere Portal Server or other application servers to add Lotus collaborative functionality to their portlets. Collaborative Components can be used to develop new custom portlets or to add collaborative functionality to existing portlets (for example, menus or people links indicating online status).
Collaborative Components are designed to provide access to the functionality of Lotus Software products enabled to work as companion products to WebSphere Portal Server. As such, the methods provided by Collaborative Services complement rather than replace the APIs of individual companion products such as the Domino Java API and the Discovery Server KDS API.
Collaborative Components provide standardized access to applications, easy-to-use APIs that are optimized for a collaborative portal, and a consistent security model across all Lotus Software companion products.
All of the Collaborative Components except for people and menu tags are UI-neutral. That is, portlet developers can design the user interface for the collaborative features they are implementing. The goal of Collaborative Components is to provide the data necessary for rendering the user interface and to allow the developer to execute actions on the Lotus collaborative products that have been installed and enabled in the portal environment.
The Java APIs in Collaborative Components contain no platform-specific code. Consequently, these components are UI-neutral and independent of implementation details. Because they are UI-neutral, Collaborative Components can be used to implement pervasive applications for mobile and wireless devices.
Since Collaborative Components hide the configuration details of the Lotus products installed within an enterprise, collaborative functionality can be easily added to a portlet in a generic way—regardless of the physical requirements and machine-dependent details of a portal configuration.
Application developers using Collaborative Components can design and implement functional extensions in portlets that incorporate the features of Lotus Domino and Notes, Team Workplace, Instant Messaging, and Discovery Server. Collaborative Components for other Lotus Software products will become available in the future. JavaDoc for Collaborative Components is installed on the Portal Server. IBMers can go to http://publib.boulder.ibm.com/pvc/wp/42/exp/en/InfoCenter/collab/ksd_cs_api_intro.html for more information.
Struts is a Jakarta open source project that allows developers to efficiently implement their Web applications using a Model-View-Controller design pattern. Struts provides the Controller component, a collection of JavaBeans and helper classes for creating the Model, and a set of tag libraries for the JSP pages.
A Struts application is made up of actions, pages,  and beans. The application writer creates these objects and defines in the struts-config.xml configuration file, the relationships between these objects, and the transitions that occur. These actions represent processing that occurs prior to going to another page. The configuration of an ActionMapping associates a path with an Action and with ActionForms and can list one or more destination pages following execution of the action. ActionForms are beans associated with actions, supplying the data to fill in various fields on a page. As a result of executing the action, an ActionForward object is returned containing the path to next request. Typically, the returned path is to a page, but it is also possible that it is to another Action.
The Struts Web site offers resources for developers, including a User Guide, informative JavaDoc, and the source code. IBMers can go to http://publib.boulder.ibm.com/pvc/wp/42/exp/en/InfoCenter/wps/wpsstruts.html for more information.
Page sequences is an extension to the Struts Portlet Framework that leverages much of the existing Struts functionality to support the design and implementation of multi-screen flows within a Struts application. This extension supports the generation of an event-driven screen-flow model that allows the developer to concentrate on solution-specific tasks.
Currently, Struts applications are left to manage navigation issues and deal with Forms whose logical contents cross page boundaries. Typical business transactions require more than one interaction with the user, therefore spanning more than one JSP page and action. Page sequences leverage much of the existing Struts functionality and extends the Struts framework to support the design and implementation of multi-screen flows within a Struts application, resulting in the following advantages:
The configuration explicitly defines the exact flow of pages and actions.
The screen flow automatically ensures that the correct sequence is followed and that the user cannot back up and submit the same form multiple times.
The screen flow supports separation of data from one screen flow to another.
If the business logic is implemented properly, the order of screens within the flow can be changed without requiring major configuration and code changes.
IBMers can go to http://publib.boulder.ibm.com/pvc/wp/42/exp/en/InfoCenter/wps/wpspageseq.html for more information.
Click-to-Action provides a framework for communication that simplifies users' interactions with portlets on a portal page. With a simple click, users can transfer data from a source portlet to one or more target portlets, causing the target to react to the action and display a new view with the results.
The Click-to-Action framework includes a runtime that automatically matches sources with compatible targets based on type information, and inserts clickable icons associated with sources on portlet pages. When users click on an icon next to a particular source, they are presented with a pop-up menu containing the list of targets for the action. After the user selects a specific target, the Click-to-Action runtime delivers the data to the target in the form of the corresponding portlet action. The portlet does not need to distinguish between an action initiated by user interaction with its own page segment and that initiated using the Click-to-Action route. This keeps the programming effort to a minimum, allowing Click-to-Action portlets to follow the normal portlet programming model.
The following tags are used by portlet or portal JSPs.
Portlet API tags
Portal JSP tags
Struts WML tags
Page sequence tags
IBMers can go to http://publib.boulder.ibm.com/pvc/wp/42/exp/en/InfoCenter/wps/wpsjspref.html for more information.
IBM WebSphere Portal V4 Developer's Handbook, SG24-6897, found at http://publib-b.boulder.ibm.com/Redbooks.nsf/9445fa5b416f6e32852569ae006bb65f/339f3d851ca75ba885256c3f00716297?OpenDocument&Highlight=0,SG24-6897-00
This IBM Redbook helps you plan and develop portlet applications using the IBM WebSphere Portal Enable and Extend offerings. The information provided in this redbook targets B2E (Business-to-Employee) enterprise applications, but most of the scenarios presented apply to B2C applications as well. In this redbook you will find step-by-step examples and scenarios showing ways to integrate your enterprise applications into an IBM WebSphere Portal environment using the WebSphere Portal APIs provided by the Portal Toolkit to develop portlets. It also discusses extending your portlet capabilities to use other advanced functions such as themes and skins, personalization, search capabilities, content management, national language support, transcoding, and Web clipping.
Elements of the portlet API are described and sample code provided. The scenarios included in this redbook can be used to learn about portlet programming and as a basis for developing your own portlet applications. You will also find numerous scenarios describing recommended ways to develop portlets and portlet applications using the APIs provided by the IBM WebSphere Portal Toolkit.
A basic knowledge of Java technologies such as servlets, JavaBeans, EJBs, and JSPs, as well as XML applications and the terminology used in Web publishing, is assumed.
A Portal Composite Pattern Using WebSphere V4.1, SG24-6869, found at http://publib-b.boulder.ibm.com/Redbooks.nsf/9445fa5b416f6e32852569ae006bb65f/309f4c3c906a089c85256bf800630def?OpenDocument&Highlight=0,SG24-6869-00
The Patterns for e-business are a group of proven, reusable assets that can speed the process of developing applications. The Portal composite pattern combines Business and Integration patterns to help implement a portal solution. This IBM Redbook provides a technical scenario and guidelines for the Portal composite pattern. It shows how the Composite pattern works and documents the tasks required to build a technical scenario of it.
Part 1 of the redbook guides you through the process of choosing the Business and Integration patterns of the Composite pattern and then drilling down to the Application and Runtime pattern and Product mapping to deliver the desired functionality of the Portal composite pattern.
Part 2 provides a set of guidelines for building your portal application and includes a discussion of application design, application development, and systems management.
Part 3 demonstrates how to implement a portal solution via a technical scenario. This technical scenario uses the WebSphere Portal Extend offering.
Portals provide a mechanism for aggregating information and access to enterprise services into a single consolidated view for the Web. A portlet (similar to a servlet) provides access to a specific application or function being made available to the user via the portal.
The IBM Portal Toolkit Version 4.3 provides the capabilities to customize and manage the enterprise portal and to create, test, debug, and deploy individual portlets and Web content. Templates enable developers to quickly and easily create their own portlets. Debugging and deployment tools shorten the development cycle. Sample portlets that demonstrate best programming practices are also provided.
The Portal Toolkit plugs into the IBM WebSphere Studio Workbench, which provides a comprehensive framework for the development of e-business applications.
IBMers can go to http://www-3.ibm.com/software/info1/websphere/index.jsp?tab=products/portaltoolkit for more information.
WebSphere portal catalog
The WebSphere portlet catalog describes portlets created by numerous companies for use with WebSphere Portal. You can find portlets for your specific needs by searching or browsing by category.
IBMers can go to http://publib-b.boulder.ibm.com/Redbooks.nsf/9445fa5b416f6e32852569ae006bb65f/309f4c3c906a089c85256bf800630def?OpenDocument&Highlight=0,SG24-6869-00 for more information.
Portlet Development Guide: Second Edition
This document shows how to develop a portlet using the Portlet API 1.2. It describes Portlet API concepts and elements, illustrating these concepts and API elements using examples ranging from a simple portlet with no output to a complex portlet application with more advanced features. Finally, it describes portlet development for the IBM WebSphere Portal Version 4.2 environment.
IBMers can go to ftp://126.96.36.199/1/wsdd/pdf/V42PortletDevelopmentGuide.pdf to view/download.
Usually JSPs but sometimes HTML pages.
|< Day Day Up >|| |