| Portlet Development Best Practices and Coding Guidelines This document is a collection of best practices for portlet development, divided into major categories. It is intended to be used as coding guidelines for designing and developing portlets with IBM® WebSphere® Portal. |
| WebSphere Portal V4 programming, Part 1: Portlet application programming In this article, David introduces the concept of portlet programming for WebSphere Portal Version 4.1. He shows you how to construct a portlet application, including the required classes and support files, and explains how to build and deploy a portlet to a working portal server. You can use the example portlets presented here as building blocks for larger portlet applications. |
| WebSphere Portal V4 programming, Part 2: Portlet application programming This is the second article in a series on developing portlets for WebSphere Portal. In this article, David and Varad introduce portlet to portlet collaboration using portlet messaging, then cover in depth some techniques to use messaging in your portlets. They also explain how WebSphere Portal supports and processes messages between portlets, and how to build the sample portlets that are included. You can use the sample portlets in this article as building blocks for highly functional messaging portlet applications. |
| Comparing the JSR 168 Java Portlet Specification with the IBM Portlet API This article explains the differences between the JSR 168 JavaTM Portlet Specification (hereafter called JSR 168) and the IBM® Portlet API of IBM WebSphere® Portal Version 5.0 (hereafter called IBM Portlet API). It explains the basic concepts of JSR 168, compares them to the IBM Portlet API, provides examples, and gives some recommendations about when to use each of these APIs. This article is intended for portlet developers and portal architects, who have a good understanding of Java programming, servlet or portlet programming, and have basic knowledge about portals. |
| WebSphere Portal V4 programming, Part 1: Portlet application programming The JSF implementation includes many standard components for building web applications, such as text fields, check boxes, buttons, and so on. However, most user interface designers want to use more advanced components, such as calendars, tabbed panes, or navigation trees, that are not part of the standard component set. Fortunately, JSF makes it possible to build reusable JSF components with rich behavior. |
| Hello World Portlet Revisited: Adding Globalization Support for Multi-languages Using WebSphere Portal 4.1.2 This article demonstrates how to create a simple globalized portlet using WebSphere Portal 4.1.2 for Multiplatforms, which supports fourteen languages, including bidirectional (BiDi) layout. The portlet will have GUIs in three languages: English, Simplified Chinese, and Hebrew. |
| Modeling WebSphere Portal Portlets with UML -- Part 3: Portlet Services A colleague of mine, who recently started to work with IBM® WebSphere® Portal (hereafter called Portal), posed the question, "What’s the best way to share functionality between portlets?" After a brief discussion to better understand what he was trying to accomplish, I suggested he consider using a portlet service. |
| Modeling WebSphere Portal Portlets with UML -- Part 2 Part 2 provides an in-depth discussion of modeling portal applications, and introduces the additional topics of modeling portlet services, EJBs, and other coalesced objects within a portal application design. |
| Modeling WebSphere Portal Portlets with UML: Part 1 Troubleshooting a JSF application can be painful. There are so many minor details that must be just right, or your application won't work. Error messages can be hard to find or nonexistent. Minor typos can give rise to an application that simply doesn't start or that seems to get stuck. |
| IBM WebSphere Developer Technical Journal: Integrating WebSphere Portal and WebSphere Personalization Part 1 of this series demonstrates how to use WebSphere Personalization 4.1 with WebSphere Portal 4.1x to create a personalized portlet and Web application. This article also describes WebSphere's rule-based personalization. |
| IBM WebSphere Developer Technical Journal: Building SAP Portlets Using IBM Application Portlet Builder IBM Application Portlet Builder, a component of WebSphere Portal Application Integrator, is a simple, intuitive tool that helps you successfully integrate key enterprise applications with IBM WebSphere Portal. You can create portlets, with comparable functions to enterprise applications. This article steps you through the process of creating portlets that access SAP, using the downloadable IBM Application Portlet Builder. |
| IBM WebSphere Developer Technical Journal: Accessing SAP Systems -- Part 2 In Part 2 of this article series, three sample scenarios will illustrate the different types of SAP applications that can be built using these WebSphere products. As each sample is built, the various artifacts that are created will be described, and the structure and benefits of each sample will be discussed. |
| Accessing SAP R/3 with WebSphere Studio Integration Edition V4.11 and WebSphere Adapter for mySAP.com V1.0 This article shows you how to use the WebSphere Studio Enterprise Services Toolkit and a Web services architecture to access SAP R/3 data and business logic. |
| Creating Common Portlet Controls Using Custom Tag Libraries This article introduces the concept of custom JSP tag library development as a tool for creating visual controls for portlet development. |
| Understanding the Portlet Component Model in IBM WebSphere Portal This paper describes the portlet component model and the Portlet API employed in IBM® WebSphere® Portal. It also includes an example of a portlet written to this API. |
| 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 its elements. It illustrates 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. |
| Portlet Team Development with WebSphere Studio Application Developer and the Portal Toolkit Plug-in The article discusses common team development scenarios using the IBM Portal Toolkit plug-in for WebSphere Studio Application Developer, and provides best practices for handling the most commonly encountered problems. |
| Developing and Debugging Portlets Using the IBM Portal Toolkit Plug-in for WebSphere Studio Application Developer (Updated) This article demonstrates how to install the IBM Portal Toolkit plug-in for WebSphere Studio Application Developer, and how to use the Portal Toolkit to develop, debug, and deploy a portlet. You will test the configuration by deploying and viewing the portlet on a remote WebSphere Application Server configuration. |
| Different Views for Modes and States - Portlet Programming for WebSphere Portal Version 4.1 The other day I got an e-mail asking how to create a portlet that changes its rendered content when the portlet's window state changes, like when the window is maximized or minimized. As this seems to be a constant point of confusion, in this article I will show you not only how to modify the portlet output based on the portlet window's state, but also how to modify the output based on the portlet's mode. |
| Hello World Portlet Rendered with JSP for WebSphere Portal Version 4.1 I've often been asked the question: "What is the simplest portlet one can create from scratch for WebSphere Portal Version 4.1?" The trite answer is "hello world". The longer, detailed answer is what this article is about. I'm going to take you through creating the simplest of portlets for WebSphere Portal. We'll start with some Java code, compile and package that. |
| Hello World Portlet Rendered with JSP for WebSphere Portal Version 4.1 In our first portal based Hello World article, we've seen how to create a portlet in Java that spits out "Hello world!". While this is instructive, it's not a pragmatic approach to developing portlets. So, what is wrong with it? One problem is the subject of this article. In the simplest "Hello World!" program, the Java code contains both the text "Hello, world!" and the logic for displaying it. It would be far better if we could separate the logic of the portlet from how it gets rendered. This allows us to create portlets that support different meta languages and national languages. |
| Rapid Portlet Design with Rational XDE Patterns, WebSphere Studio and the IBM Portal Toolkit Rational® eXtended Development Environment (hereafter called Rational XDE™) is a powerful tool for designing, developing, deploying and documenting Java™ applications. By using Rational XDE with the Unified Modeling Language (UML), or free-form models, developers can model and visualize applications and application behavior. Since Rational XDE is integrated in IBM® WebSphere® Studio Application Developer (hereafter called Application Developer), there's no need to switch tools during the development lifecycle. |
| Connecting a Portlet to Access Web Resources This article describes four techniques for developing portlets to access Web resources: exploiting predefined portlets, using the ContentAccessService portlet, generating an IFRAME tag in the output of the portlet's stream, and accessing a Web service using the SOAP (Simple Object Access Protocol) API. |
| Pervasive Portlet Development This introduction to portlet programming in a pervasive environment builds on the fundamental concepts of portlet design to facilitate easy application development using IBM WebSphere Portal for devices such as Palm handhelds, Pocket PCs, and SmartPhones. |
| Install an existing portlet: Adding functionality to WebSphere Portal In their quest to create MetroSphere, a community weblog and information marketplace, the MetroSphere team is building the site using IBM WebSphere Portal, which is built on a collection of small applications called portlets. In this article, Nick Chase obtains a pre-written portlet application for request tracking and installs it on the portal. |
| An Example JavaServer Faces Page To see how much easier Web development is with JavaServer Faces technology, it helps to look at the differences between a JavaServer Faces page and a JSP page. The following JSP page comes from the Web Applications chapter of The Java Web Services Tutorial. This page asks you to type your name into a text field and click the button |
| Getting on the Express way MetroSphere.com is an online technical community and information marketplace built with WebSphere Portal. When it's complete, MetroSphere.com will allow consultants, programmers, and technical writers to gather and share information, tips, and techniques, while at the same time providing a customized portal to information of their choice. MetroSphere.com will be a place where individuals and companies sell and barter technical content and services, as well as enable better collaboration and workflow on new and existing projects. In this series of articles, tutorials, and tips from Studio B, we share our experiences as we build the MetroSphere portal. |
| Creating the project plan The first step in planning the MetroSphere.com project was to get together the Powers That Be and talk to them about what they wanted the site to be. We knew that we wanted the site to act as a marketplace for technical information, where authors could offer content in an electronic form for sale, but what else did we want? |
| Choosing a Business pattern Team Lead Nicholas Chase examines some of the common situations described by IBM Patterns for e-business, taking advantage of the various cases, some providing application architecture and even sample code to help get a project started. In this article, the team puts the experience of others to work, and applies it to their own project while focusing on Collaboration, Access Integration, and WebSphere Portal patterns. |
| Securing your WebSphere Portal - Express server Tom Syroid, Project System Administrator, addresses the first step in setting up a server that will be accessible from the Internet - - making sure it's secure. He explains the issues that need to be considered before WebSphere Portal is installed, covering topics such as physical security, network security, operating system security, application security, user management, and file permissions. |
| Making of MetroSphere, Part 5: Installing WebSphere Portal Express The first step in the MetroSphere project is getting the software installed so we can start working with it. This tutorial explains the necessary hardware and software prerequisites for installing WebSphere Portal - Express, and then explains the information necessary for a Quick Install and describes how that process should work. It also looks at some of the additional information necessary for a Standard Install. |
| Making of MetroSphere, Part 6: Getting started with WebSphere Portal - Express This tutorial is for developers and administrators who want to get familiar with WebSphere Portal in general, and WebSphere Portal - Express in particular. It explains basic concepts such as portlet use and administration, user administration, and the basics of creating portal pages. |
| Making of MetroSphere, Part 7: Page Customization with WebSphere Portal - Express Nicholas Chase chronicles the differences between WebSphere Portal - Express and the newly released WebSphere Portal Enable V4.2, and describes the steps the team took to create the first part of the main MetroSphere portal. The Studio B team has been using WebSphere Portal - Express for their work on MetroSphere while waiting to install WebSphere Portal Enable. Now the new box has arrived and it's time to move forward. |
| The making of MetroSphere, Part 8: Moving to WebSphere Portal EnableMoving to WebSphere Portal Enable : Pruning the process, planning the path Nicholas Chase chronicles the differences between WebSphere Portal - Express and the newly released WebSphere Portal Enable V4.2, and describes the steps the team took to create the first part of the main MetroSphere portal. The Studio B team has been using WebSphere Portal - Express for their work on MetroSphere while waiting to install WebSphere Portal Enable. Now the new box has arrived and it's time to move forward. |
| The making of MetroSphere, Part 9: Installing and securing Red Hat Linux The MetroSphere series follows the creation of the MetroSphere community and information marketplace. This article describes aspects of installing and securing a Red Hat Linux 8.0 server in preparation for installing WebSphere Portal Enable. |
| Making of MetroSphere, Part 10: Installing WebSphere Portal Server 4.2 on Red Hat Linux: DB2 and IDS This tutorial details the procedures necessary to install IBM WebSphere Portal Enable, Version 4.2, on Red Hat Linux. Because this topic is complex, we've split the information into two parts. This tutorial covers the installation of DB2 and IBM Directory Server (IDS). A follow-up tutorial outlines the installation of DB2, WebSphere Application Server, and WebSphere Portal Server. |
| Making of MetroSphere, Part 11: Installing WebSphere Portal Server 4.2 on Red Hat Linux: WebSphere Application Server and Portal Server This tutorial details the procedures necessary to install IBM WebSphere Portal Enable, Version 4.2, on Red Hat Linux. Because this topic is complex, we've split the information into two parts. A previous tutorial covered the installation of DB2 and IBM Directory Server (IDS). This tutorial outlines the installation of DB2, WebSphere Application Server, and WebSphere Portal Server. |
| Making of MetroSphere, Part 14: Create a new theme Look and feel are important in Web portal design. Learn how to develop themes -- which provide the look and feel for a group of pages -- and skins -- which provide the look and feel for portlets -- in this tutorial from the MetroSphere team. Topics covered include the creation of a new template theme, installing the new theme, adding WebSphere Portal functionality to the theme, accessing language-dependent text, creating URLs within WebSphere Portal, and creating and installing new skins. |
| The Making of MetroSphere, Part 15: Making tag libraries available throughout the portal Adding functionality such as JSP tag libraries to a portlet application is easy: simply include the appropriate files when creating the WAR file. But what if you need to use that tag library outside the portlet application? This tip follows the addition of the blogutil tag library to the MetroSphere portal's registration page. |
| Making of MetroSphere, Part 16: Secure version management with CVS In this tutorial, system administrators Brian Bilbrey and Tom Syroid outline the requirements necessary to transform CVS into a secure application -- from both the server and client side of the equation -- as part of Studio B's MetroSphere project. |
| The making of MetroSphere, Part 17: A cost-effective backup solution for MetroSphere This article outlines the backup strategy we put into place for MetroSphere. It details the hardware configuration, operating system (configuration, partition layout, etc.), and software solution chosen. And while some of the pieces discussed are solution-specific, the methods and implementation can easily be extrapolated to a variety of scenarios and needs. |
| The making of MetroSphere, Part 18: Three ways to link to a specific page WebSphere Portal Server makes it easy to automatically generate links to entire pages and groups of pages, but what if you just want to link to one specific page, such as an "About us" page? This tip looks at three ways of pointing directly at a piece of content. |
| The making of MetroSphere, Part 19: Creating a new administrator It's never a good idea to have one of your administrators use the default administrative account for a system, let alone all of them. This tip explains how the MetroSphere staff added new administrative accounts -- and limited their power to just what they needed. |
| Making of MetroSphere, Part 20: Creating portlets: Implementing and deploying the MetroSphere.com blogging system This tutorial is for developers who need to create portlet applications for WebSphere Portal Server 4.x. Part of the MetroSphere series, it details the creation of a community weblog application using portlets and JavaServer Pages, including links and forms within the portlets. |
| The making of MetroSphere, Part 21: Create custom user attributes Add information to a portal user record There comes a time in every portal's life when it needs to know something specific about its users in order to provide the best possible user experience. On the MetroSphere site, that point came when the team needed to determine the topics in which a particular user was interested so they could use them to "narrow down" the blog entries with which he or she was presented. This article explains how to create custom user attributes for the user to enter during registration and how to use them from within a portlet. |
| Making of MetroSphere, Part 12: Hands-on JSP technology intro: Creating a community weblog This tutorial is for developers who want to learn more about using JavaServer Pages (JSP) technology to build applications. It discusses the basics of JSP components in general, their integration with JavaBeans, and the creation and use of custom tag libraries. |
| The Making of MetroSphere, Part 15: Making tag libraries available throughout the portal Adding functionality such as JSP tag libraries to a portlet application is easy: simply include the appropriate files when creating the WAR file. But what if you need to use that tag library outside the portlet application? This tip follows the addition of the blogutil tag library to the MetroSphere portal's registration page. |
| The making of MetroSphere, Part 22: Set topics -- custom attributes and user sessions Nick showed you how to add a custom attribute to users' information that represented their preferred topics. In this article, he shows you how to use that custom attribute as well as session information to enable users to choose between showing all topics and showing only their preferred topics. |
| The making of MetroSphere: Send messages between portlets Sometimes, in the development of a portal, you need two portlets to talk to each other. For example, on MetroSphere, when the user clicks a topic in the Topic List portlet, the team needs the information to be sent not only to the Topic List portlet, but also to the Show Blog portlet. This portlet describes the process for sending messages between portlets and recording the information in the PortletSession object. |
| Making of MetroSphere, Part 24: Giving the user control - the ultimate portal theme The heart of the MetroSphere site is the community weblog, but we also want to give users the ability to create pages that reflect their own personalities. Portal enables an administrator to add a new theme to the site, but because allowing users to add a new theme involves unacceptable security risks, built-in capabilities limit user control to selecting from available themes. This tutorial explains how to give users much of the same power they would have by creating a new theme without actually creating one. |
| Developing and Invoking a Servlet from a Portlet using WebSphere Studio One of the primary goals of JavaServer Faces technology is ease-of-use. This includes separating out the code from the page so that a wider range of page authors can easily contribute to the Web development process. For this reason, all JavaScript is rendered by the component classes rather than being included in the page. |
| Developing and Invoking a Servlet from a Portlet using WebSphere Studio This article demonstrates how to create a servlet and a portlet for your Web application, and then package them into a single Web archive (WAR) file using WebSphere Studio and the Portal Toolkit plug-in. This articles then describes how to display an HTML form from the portlet code, and how to invoke the servlet from the portlet by passing the user-submitted form values. The sample code you will create calculates monthly mortgage payments; you can use the servlet code you develop here for your own servlet development. |
| IBM WebSphere Developer Technical Journal: Integrating WebSphere Portal and WebSphere Personalization -- Part 2 This article describes how to build a personalized portlet on WebSphere Portal V4.2 platform. New features of V4.2 as well as best practices based on a new approach for building personlized portlets are pointed out along the way. |
| Extending the State Pattern for Multi-Portlet Applications This article describes how to extend the state pattern to multi-portlet applications and provides techniques to effectively design these applications. It then shows how to implement multi-portlet applications and provides an implementation example for WebSphere Portal V5.The implementation is deployed in the WebSphere Portal Test environment for IBM WebSphere Studio Application Developer. |
| Using XML Access to Deploy Portlet Services This article describes how to use advanced XML Access routines to update portal properties and deploy portlet services. |
| Developing an XML request file for XML Access in WebSphere Portal Version 4.1 The XML Access configuration client interface included with WebSphere Portal Version 4.1 allows exporting entire or partial configuration settings as an XML file and recreating configurations by importing the XML file. This interface can also be used as an alternative to performing some administrative tasks as part of the Portal Administration place and the Work with Pages place within the portal server. |
| Using the Portal Style Sheet Elements in a Portlet WebSphere Portal V4 provides style sheet elements that you can use in a portlet to display HTML elements such as forms and tables. Using these style sheet elements in portlets enables visual consistency among all the portlets on a page. This article includes sample code which shows you how to use these style sheet elements in a portlet. |
| Create your own portlet and Web service In this article, Michael Wanderski introduces you to portlet and Web Services programming. By building a functional example step-by-step, he shows the vast potential and benefit of combining these two exciting new technologies. This article is intended for developers with at least some level of portlet and Web services knowledge, though extensive experience is not required. |
| Build custom portlets for Domino: Portlet Builder for Domino simplifies development The key to deriving the most value from a portal deployment is to aggregate data, content, and processes from existing applications, such as Domino. This provides users with custom views into the applications they need to do their jobs. In other words, the key lies in building portlets. However, building portlets can be a time-consuming process. With Portlet Builder for Domino, WebSphere users now have a new no-code option: using a portlet to build more portlets. This tutorial teaches you everything you need to know to get started, from downloading the code to creating and using your own custom portlet. |
| Building Lotus Domino Portlets: Bowstreet Portlet Factory for WebSphere streamlines the process This tutorial demonstrates how to build portlets that leverage Lotus Domino data using the Bowstreet Portlet Factory for WebSphere. More specifically, it demonstrates using the Lotus Collaboration Extension for Bowstreet Portlet Factory, which allows you to quickly create Domino portlets without writing any Java code or learning the Domino or WebSphere Portal Java APIs. The Bowstreet Portlet Factory streamlines the development, deployment, and maintenance of custom portlets that plug into the IBM WebSphere software platform. |
| WebSphere Portal: Portlet Concepts and Guidelines This paper explains WebSphere portal terminology, defines the objects you will encounter when developing portlets, and shows their relationship in several contexts, such as: how these objects relate to servlets and object-oriented programming, to your development tasks, and to the lifecycle of a portlet. It includes details on configuring and using these objects in your portlet applications, and offers several handy guidelines that can make portlet programming easier. |
| Quick Start for Installing WebSphere Portal V5 and the Portlet Development Environment During the Render Response phase, the JavaServer Faces implementation calls the getRendererType method of the component's tag to determine which renderer to invoke, if there is one. |
| Quick Start for Installing WebSphere Portal V5 and the Portlet Development Environment Get a jumpstart to installing IBM WebSphere Portal V5.0 with IBM DB2 V8.1 and extended security, using an LDAP directory, IBM Directory Server V5.1, on a single Windows node. See also how to set up a portlet development environment by installing and configuring WebSphere Studio Application Developer 5.0. |
| Jetspeed, Part 2: Advanced portlet technology Ready... set... Jetspeed those portlets. In this follow-up tutorial on Jetspeed as used in portlet development, regular contributors Roman Vichr and Vivek Malhotra further the knowledge you gained in Part 1 by teaching you how to stream into the portlet you've created using Web programming technologies. |
| Setting up a Portlet Development Environment Using WebSphere Studio V5.0.1 and Portal Toolkit 4.3 This article provides detailed steps for installing and configuring a portlet development environment using IBM® WebSphere® Studio Application Developer Version 5 (hereafter called Application Developer) and Portal Toolkit Version 4.3. |
| Setting up a Portlet Development Environment Using WebSphere Studio V5.0.1 and Portal Toolkit 4.3 This article provides detailed steps for installing and configuring a portlet development environment using IBM® WebSphere® Studio Application Developer Version 5 (hereafter called Application Developer) and Portal Toolkit Version 4.3. |
| Vignette V7 Portlets for WebSphere Portal Version 4.2 The WebSphere Portal Server (WPS) Portlet Library for V7 contains a set of portlets that integrate with the Vignette V7 Content Management System. These portlets can display, search, and manage Vignette content. You can configure the portlets to retrieve content from one of the Vignette defined stages. |
| Developing Sametime V3 Portlets with WebSphere Portal V4.2 This tutorial demonstrates how to integrate the Sametime 3.0 Java Toolkit into a WebSphere Portal environment, without requiring the full Lotus Collaborative Components or Collaboration Center from WebSphere Portal. |
| WebSphere Portal Extend V4.2.1 with Lotus Sametime 3.0: Enabling Collaboration for Portal Users IBM® WebSphere® Portal integrates with collaboration components, including Lotus® Sametime®. This tutorial demonstrates how to install and integrate Lotus Sametime V3.0 with WebSphere Portal Extend V4.2.1 so that you can enable collaboration capabilities for portal users. You learn how to use WebSphere Portal and Sametime together to provide portal users with instant messaging capabilities and application sharing through e-meetings. |
| Using Credential Vault to Provide Single Sign-on for Portlets Some portlets that run on WebSphere Portal server need to submit credentials (for example, a user ID and a password) to back-end remote applications. If the remote applications use the same credentials as those used by WebSphere Portal, then portlets can re-use them. Portlets can use the Java Authentication and Authorization Service (JAAS) API to extract those credentials, and then submit them to the remote applications. However, it is not always possible for a remote application to use the same credentials as those used by WebSphere Portal. |
| IBM WebSphere Developer Technical Journal: WebSphere Everyplace Access V4.2 Programming Portals provide a consolidated interface for applications that are customizable through preferences, tailored with unique layouts, and personalized through selectable content. Portlets are Web-based applications which interact within the portal structure and collaborate with other portlets. The next step in portal evolution is extending the reach to pervasive devices, which are not always connected to the internet and may roam in and out of connectivity |
| Applying the State Pattern to WebSphere Portal Portlets -- Part 2: Implementation Portlet development guidelines and example implementations provide a good understanding of the portlet API. However, implementing complex process control is outside the scope of the API. Without a well-designed approach to this problem of how to best implement control logic, you end up creating portlets that contain a fair amount of code dedicated to simply addressing the intent of a user's request. |
| Applying the State Pattern to WebSphere Portal Portlets -- Part 1: Overview IBM® WebSphere® Portal (hereafter called Portal) is quickly becoming a standard platform for building enterprise class applications. Moving beyond the simple HelloWorld portlet, developers are starting to establish standard frameworks for building portlets |
| Developing a Struts Application for WebSphere Portal 4.2 In this article, we will discuss an implementation of a Web application, written first as a servlet-based Struts application, and then deployed as a portlet in IBM WebSphere® Portal. Struts, part of the Apache Jakarta Project, provides a very popular open source framework for building Web applications. WebSphere Portal, Version 4.2, provides the Struts Portlet Framework that supports the deployment of Struts applications as portlets. The Struts Portlet Framework also provides support for portal mode and device support within a Struts applications. |
| The Go-ForIt quest continues, Part 5: How portlets extend Go-ForIt's Web services In this series about the dragonslaying technical consulting team, we've described how to take an existing J2EE project and move parts of it onto a portal server. This article describes how to develop portlets by accessing the Web services in Go-ForIt. We discuss the architecture and design of the portlets from existing JavaServer Pages (JSP) components, command beans, and Web services in the Go-ForIt B2C application. |
| Meet the Experts: David Lection on WebSphere Portal development This question and answer article features David Lection, lead architect for Portal Toolkit for WebSphere Portal, who answers top questions from WSDD users about portlet development techniques. |
| Develop portlets that use Web services to obtain data from remote systems Web services are becoming the predominant method for making information and applications programmatically available on the Internet. Portals are becoming the main means to integrate information and applications from the intranet and Internet. IBM WebSphere Portal for Multiplatforms Version 4.x supports easy integration of remote portlets as visual Web services |
| Giving Users More for their Clicks in WebSphere Portal A Programmatic Approach to On-the-Glass Integration of portlets In this paper, we describe an easy-to-implement scheme for increasing user productivity, using features of the Portlet programming model in WebSphere Portal. We illustrate how information displayed on one portlet can be transferred to and acted upon by another portlet on the same page. You can select specific fields in your portlets that might be useful to other portlets within the same page. For instance, you might want to expose the name of the destination city from a travel booking portlet. A weather portlet within the same portal application could then display weather-related information for that destination city. |
| Accessibility for Portlets Developed for IBM WebSphere Portal for Multiplatforms Version 4.1 -- Part 1 If your portlets need to meet accessibility standards, this article series can help. Part 1 discusses tips and tricks for using WebSphere Portal 4.1 to implement portlet accessibility. |
| Advanced Web Clipping Using WebSphere Portal Version 4.1 In our last article, Basic Web Clipping Using WebSphere Portal Version 4.1, we introduced the concept of Web clipping and discussed Web clipping basics such as: how to access the Web Clipping Portlet, how to add, edit, and remove a Web clipper, and how to add a finished Web clipper to a page within your portal. We demonstrated these techniques by building a simple Web clipper (sometimes called a cliplet) that used Web clipping technology to present a clipped version of a simple HTML Web page, tailored to show selected portions of the content. |
| WebSphere Portal Programming : Portal Aggregation for Pervasive Devices This article discusses how page aggregation works for devices that support markup languages for pervasive devices, such as Wireless Markup Language and Compact HTML. It describes how to add support for new pervasive devices, and, as an example, it demonstrates how to add support for Pocket PC devices. The examples in this article use WebSphere Portal Version 4.1. |
| DB2 Content Manager Version 8.2 Web Access Options DB2® Content Manager V8.2 (CM V8.2) provides the ability to manage the 80% of business content that is not relational data. This content crosses the spectrum from scanned images of paper documents, through the content created by office programs, to the video streams used by CNN. |
| End-to-end Mobile Enterprise Information Systems Solutions with IBM WebSphere Products Today, many enterprises are evaluating and selecting middleware vendors to provide mobile solutions for their existing Enterprise Information Systems (EIS) applications. IBM® understands enterprise requirements, and has developed products to provide secure and scalable, end-to-end enterprise mobile solutions. |
| Options for portalizing Domino applications Several options exist for exposing a Domino application to a portal audience. A developer can use a tool such as WebSphere Portal Application Integrator and the Portlet Builder for Domino to simply pull information, build a more tightly integrated view using products such as the Bowstreet Portlet Factory, create a portlet that retrieves Domino data via a Web Service, or create the portlet from scratch using the Domino Portlet API. This tutorial provides an overview of each of these techniques and their pros and cons. |
| Developing Portlets for WAP Devices Using the Portal Toolkit This article uses a simple scenario to illustrate the process you would follow to create a portlet for a WAP device. It includes a brief overview of the Wireless Access |
| Making of MetroSphere, Part 25: Concrete portlets and using persistent data This tutorial is for WebSphere Portal developers who need to associate persistent data with portlets, whether that data represents settings such as database usernames and passwords or user-specific customization choices. It takes the user theme portlets built in Part 24 of this series, "The ultimate portal theme," and merges the separate portlets into a single portlet with configuration choices. It also details the creation of a portlet users can edit to show their own particular favorite sites. |