Java Portlet Specification Overview

The Java Portlet Specification is a widely adopted standard for developing web applications that are modular, reusable, and highly customizable.

The specification defines a common API for portlets, which are small, self-contained applications that can be easily integrated into larger web portals.

Portlets are designed to be highly modular, allowing developers to create and reuse them across different web applications.

The Java Portlet Specification provides a flexible and scalable framework for building complex web applications that can be easily maintained and updated.

By leveraging the Java Portlet Specification, developers can create web applications that are highly customizable, scalable, and secure.

Consider reading: Samsung Galaxy J7 Phone Specification

The Java Portlet Specification is a set of standards that enables software developers to create portlets that can be plugged into any portal supporting the standards.

Portlet standards, such as the Java Portlet Specification, provide a platform-independent application programming interface for creating portlets. This means that developers can create portlets that can be used on any portal, regardless of the underlying technology.

Curious to learn more? Check out: Enterprise Portal

The Java Portlet Specification was first developed under the Java Community Process as Java Specification Request JSR 168, and released in its final form in October 2003. It introduced the basic portlet programming model, which includes two phases of action processing and rendering to support the Model–View–Controller pattern.

Here are the key features of the Java Portlet Specification:

Java Source is where the magic happens. In the example provided, we see that the Quote1HelloWorldPortlet.java file is located in the src/main/java/com/ociweb/portletapi directory.

The GenericPortlet convenience class is used as a parent class for the Quote1HelloWorldPortlet. This class dispatches requests to the doView, doEdit, or doHelp method depending on the portlet mode.

The doView method is where the portlet's view is generated. In this example, it's a simple HTML fragment that includes a portlet-section-header, a portlet-section-body, and some text.

Here are the key methods and classes used in the example:

The doView method sets the content type to text/html and gets a PrintWriter to output the HTML fragment. The HTML fragment includes a portlet-section-header and a portlet-section-body, along with some text.

Consider reading: Portlet

The Java Portlet Specification is a set of standards that allows software developers to create portlets that can be plugged into any portal supporting the standards.

These standards are platform independent, meaning they can be used across different operating systems and devices. An example of a Java portlet is the Java Servlet, but instead of producing complete documents, it produces fragments.

A Java Portlet Specification (JSR) defines a contract between portlets and the portlet container, providing a convenient programming model for Java portlet developers.

JSRs are developed under the Java Community Process and are released in different versions, each with its own set of features and improvements.

Here are the different versions of the Java Portlet Specification:

Each version of the Java Portlet Specification has its own set of features and improvements, such as inter-portlet communication, serving dynamically generated resources, and introduction of portlet filters and listeners.

The Java Portlet Specification V1.0, also known as JSR 168, was released in October 2003. It introduced the basic portlet programming model with two phases of action processing and rendering to support the Model–View–Controller pattern.

JSR 168 introduced portlet modes, enabling the portal to advise the portlet what task it should perform and what content it should generate. This feature allows portlets to adapt to different modes, such as viewing, editing, or helping.

The specification also introduced window states, indicating the amount of portal page space that will be assigned to the content generated by the portlet. This feature helps portlets to optimize their layout and content based on the available space.

JSR 168 included a packaging format to group different portlets and other Java EE artifacts needed by these portlets into one portlet application. This format simplifies the deployment process and makes it easier to manage portlet applications.

Here are the key features of JSR 168:

These features provide a solid foundation for building portlet applications and have been widely adopted in the industry.

A portlet is a pluggable user interface software component that is managed and displayed in a web portal. It responds to requests from a web client and generates dynamic content.

Portlets can be used for various applications, such as e-mail, weather reports, discussion forums, and news. These applications can be easily integrated into a web portal.

A portlet window consists of a title bar with the portlet's title, decorations, and the content produced by the portlet. The decorations can include buttons to change the portlet's window state and mode.

For more insights, see: Title of Specific Page Nextjs

Components are the building blocks of a portlet structure. They are software components that are managed and displayed in a web portal.

A portlet can be as simple as an e-mail application, which responds to requests from a web client. It generates dynamic content that is displayed to the user.

Portlets can also be more complex, like a discussion forum, which allows users to interact with each other. This type of portlet requires more advanced functionality and user management.

Some portlets, like those that display weather reports, generate dynamic content based on external data feeds. This means they can update their content in real-time, without requiring manual intervention.

Each portlet application has its own unique characteristics and requirements. However, they all share the common goal of providing dynamic content to the user.

Consider reading: Java Programming for Web Development

A portlet container is responsible for running portlets and providing them with the required runtime environment. This allows portlets to function smoothly and efficiently.

Portlet containers receive requests from the portal to execute requests on the portlets hosted by them. This is a crucial function of a portlet container.

A portlet container contains portlets and manages their life cycles. This means it takes care of creating, updating, and deleting portlets as needed.

The portlet container provides persistent storage mechanisms for the portlet preferences. This ensures that user settings and preferences are saved and can be retrieved when needed.

A portlet container is not responsible for aggregating the content produced by the portlets; the portal itself handles aggregation. This means the portlet container focuses on running the portlets, while the portal handles combining their output.

Expand your knowledge: Html Java Function

The page is a complete markup document that aggregates several portlet windows.

It may also consist of navigation areas and banners.

A portlet window consists of a title bar with the portlet’s title.

Decorations can include buttons to change the portlet’s window state and mode.

Separate Presentation Logic is a key concept in portlet development. It involves separating the data acquisition from the presentation logic to make the code more maintainable and efficient.

In Java Server Pages (JSP) technology, this can be achieved by delegating HTML fragment generation to a JSP. For example, in the Quote3RenderJSPPortlet.java code, the HTML fragment generation is delegated to a JSP by setting the "quote" attribute in the request and then including the JSP file using the getRequestDispatcher() method.

The JSP file uses the portlet tag library to access portlet-specific elements, such as the renderRequest. This allows the JSP to retrieve the quote object from the request attribute and display its data.

Here are the key steps to separate presentation logic using JSP:

By separating presentation logic, developers can make their code more modular, reusable, and maintainable. This approach also facilitates the use of the Model-View-Controller pattern, where the portlet acts as the controller, fills a bean with data, and includes a JSP page to render the output.

Portlet Configuration is a crucial aspect of the Java Portlet Specification. The portlet.xml file contains configuration information for the portlets, as described in the JSR 286 specification.

A portlet.xml file typically includes a portlet-app element, which contains a portlet element. The portlet element has a portlet-name element, a portlet-class element, and an expiration-cache element. For example, the Quote1HelloWorldPortlet has a portlet-name of "Quote1HelloWorldPortlet" and a portlet-class of "com.ociweb.portletapi.Quote1HelloWorldPortlet".

The portlet.xml file also defines public render parameters, which can be used to share render parameters between portlets. This is done by declaring the public render parameters at the portlet application level and specifying the render parameter to be shared in the portlet section of the portlet.xml file.

Here is a list of the key elements in a portlet.xml file:

Custom modes allow you to affect the end user's ability to edit the portlet or display Help for the portlet. You can also create custom modes.

There are three required modes that every portal must support: Edit, Help, and View. A portlet must at least support the View mode used to render markup for a page.

Custom modes fall into two categories: portal managed and not portal managed. To add a custom portlet mode, you can double-click the New Custom Mode node in the Portlet Editor Controls part of the Design Palette.

Portal vendor-specific modes are not defined in the specification and are therefore vendor specific. Custom modes are inserted into the portlet.xml file and can be shared by multiple portlets.

Here are the three categories of portlet modes:

A portlet can use only portlet modes or window states supported by the portal running the portlet. The portlet can use the PortalContext‘s getSupportedPortletModes() and getSupportedWindowStates() methods to retrieve the portlet modes and window states the portal supports.

Related reading: WebSphere Portal

Portlets can be configured to support different modes and states, which affect how the end user interacts with them. The Java portlet specification defines two main categories of portlet behavior: modes and states.

Modes allow you to affect the end user's ability to edit the portlet or display Help for the portlet, and can be categorized into required modes, optional custom modes, and portal vendor-specific modes. Required modes include Edit, Help, and View, while optional custom modes include About, Config, Edit_defaults, Preview, and Print.

A portlet mode indicates the function a portlet performs, and can be changed programmatically when processing an action request. Here are the three categories of portlet modes:

States determine the end user's ability to affect the rendering of a portlet, such as to maximize or minimize the portlet. The Java portlet specification defines three window states: Normal, Maximized, and Minimized. A portlet can be called in any of these three window states, but is free to produce the same markup for all three states.

A portlet mode indicates the function a portlet performs, and can be one of the required modes, optional custom modes, or portal vendor-specific modes.

JSR 168 splits portlet modes into three categories: required modes, optional custom modes, and portal vendor-specific modes. Required modes include Edit, Help, and View, while optional custom modes include About, Config, Edit_defaults, Preview, and Print.

Custom portlet modes can be added, and can be either portal managed or not. Custom modes are inserted into the portlet.xml file and can be shared by multiple portlets.

A window state indicates the amount of portal page space that will be assigned to the content generated by a portlet. The three defined window states are Normal, Maximized, and Minimized.

Here are the three window states defined by JSR 168:

Sessions in portlet applications are based on the HttpSession concept used in Web applications.

The HttpSession is used by servlets, and since portlet applications are also Web applications, they use the same session.

The default session scope in portlet applications is the portlet scope, which allows portlets to store temporary data private to a portlet.

Attributes stored with this scope are prefixed in the session by the portlet container to avoid two portlets overwriting each other's settings.

Portlet applications also support the Web application session scope, which allows every component of the Web application to access the information.

This shared information can be used to share transient state among different components of the same Web application, such as between portlets or between a portlet and a servlet.

Public Render Parameters allow portlets to share parameter values with other portlets, enabling interportlet communication. This feature is a part of JSR 286.

You can declare public render parameters in the portlet.xml file by setting the public render parameters at the portlet application level. This is done by adding a public-render-parameter element in the portlet application section.

Public render parameters can be accessed in all lifecycles of the portlet: processAction, processEvent, render, and serveResource. This is in contrast to render parameters, which can only be accessed during the processAction lifecycle.

To add public render parameters to a Java portlet, you need to update the portlet.xml file and the .portlet file. An application-scoped public-render-parameter element is added to the portlet.xml file, and a supported-public-render-parameter element is added to the portlet section.

The supported-public-render-parameter element must reference the identifier of a public render parameter defined in the portlet application section. This allows the portlet to share the parameter with other portlets.

Public render parameters can also be shared with non-JSR-286 portlets, where they are called "shared parameters". For more information, see Section 9.3, "Using Shared Parameters".

Here's an interesting read: Xml Parser Java

As you work on your portlet, you might want to consider how it can respond to user preferences. In the context of portlets, preferences refer to the ability to store and retrieve user-specific data. This can be achieved through the use of portlet preferences, which provide a way to associate application data with portlets.

Portlet preferences are a key feature of portlets, allowing users to personalize their experience. To access these preferences, you can use the PortletRequest interface, which provides methods for retrieving and storing preference data. For example, you can use the getPreferences() method to retrieve the user's preferences and then use the getValue() method to retrieve a specific preference value.

To give users the ability to edit their preferences, you can use the doEdit() method, which is a part of the GenericPortlet parent class. This method is used to render the portlet in edit mode, allowing users to make changes to their preferences. In the case of the Quote4PreferencesPortlet example, the doEdit() method is used to render a form that allows users to edit the number of quotes being displayed.

The processAction() method is another important part of portlet behavior, as it is used to handle action requests and make changes to the portlet's state. In the case of the Quote4PreferencesPortlet example, the processAction() method is used to store the user's preference changes and update the portlet's state accordingly.

Here's a summary of the key methods and concepts involved in responding to user preferences:

Event handling is a crucial aspect of portlet behavior. It allows us to respond to user interactions and other events that occur within the portlet.

Portlets can handle various events, including action events, which are triggered when a user clicks a button or link within the portlet. Action events can be used to perform actions such as saving data or displaying a new page.

Event handling is typically done using event listeners, which are methods that are called when an event occurs. These methods can be used to perform any necessary actions, such as updating the portlet's content or sending data to the server.

Portlets can also handle errors, which can occur when an event is triggered but the portlet is unable to handle it. Error handling is an essential part of portlet behavior, as it ensures that the portlet remains stable and functional even in the event of an error.

Event handling is typically done using a combination of event listeners and error handling mechanisms. This allows us to respond to events and errors in a flexible and robust way.

Caching is a powerful tool in Portlet Behavior that allows for efficient rendering of content. JSR 168 defines support for expiration-based caching.

You can define the expiration time for a portlet's response in the deployment descriptor. This means you can control how long cached content remains valid.

The portlet can also set an expiration time for the render response using the EXPIRATION_CACHE property. This gives you more flexibility in managing cache expiration.

Any request targeted to this portlet automatically expires the cached content. This ensures that the portlet gets called independently of the remaining cache expiration time.

Localization is a key aspect of portlet behavior, and the Portlet Specification provides two levels of localization: deployment descriptor and portlet.

On the deployment descriptor level, settings like portlet description, init parameters, and display name can have an xml:lang attribute to provide descriptions in different languages.

The xml:lang tag is used to provide multiple language options, such as a display name in English, German, and Japanese.

A resource bundle class is set in the deployment descriptor to contain the portlet title's localized versions, short title for graphically restricted devices, and keywords describing the portlet's functionalities.

The PortletContext's getResourceBundle() method allows the portlet to access the resource bundle.

Localization of preference attribute display names, values, and descriptions is also recommended, and the specification provides a notation for this purpose.

Portlet deployment is a two-step process that involves deploying the Web application into the application server and the portlets into the portal server. This is because portlet applications have two deployment descriptors: web.xml and portlet.xml.

The portlet.xml file is used to specify portlet resources and settings, while the web.xml file is used to specify Web resources that are not portlets. There are three exceptions to this rule: the portlet application description, name, and security role mapping, which are all defined in the web.xml file.

A portlet.xml file always describes only one specific portlet application, and to create a copy of a portlet application with slightly different settings, a new portlet application must be created.

Here are the three exceptions to the rule that are defined in the web.xml file:

In the future, the Portlet Specification will address the needs of more complex portlet applications that require more interaction between portlets.

Portlet Advanced Topics are a crucial aspect of the Java Portlet Specification. They allow developers to access user information, a valuable resource for personalizing the user experience.

You can access user information using the Portlet API's advanced features, which enable you to retrieve user details such as their profile, preferences, and session data. This information can be used to tailor the portlet's content and behavior to individual users.

The calling portal's context is also an important consideration in Portlet Advanced Topics. By accessing this information, developers can determine the portal's settings, layout, and other relevant details. This knowledge can be used to adapt the portlet's appearance and functionality to match the portal's design.

JSR 362 is a significant release in the Java Portlet world. It was released in April 2017.

One of its key features is Resource Dependencies, which allows developers to manage dependencies between resources more efficiently.

JSR-362 also introduced Explicit Render State, a feature that enables developers to control the rendering of portlets more accurately.

Another notable feature is CDI 1.2 Integration, which enables seamless integration with Contexts and Dependency Injection (CDI) 1.2.

Servlet 3.1 Alignment is also a part of JSR-362, ensuring that portlets can take advantage of the latest features in Servlet 3.1.

Portlet Hub & XHR IPC is a feature that enables communication between portlets using Portlet Hub and XHR (XMLHttpRequest).

FacesBridge Integration via JSR 378 is also included in JSR-362, allowing for integration with JSF (JavaServer Faces) applications.

Aliases can be used to coordinate between two portlet applications that use different event names. This is particularly useful when you have two portlets, like PortletA and PortletB, that use different names for the same event.

To add an alias, you'll need to add the same qname of the event of the other portlet in the portlet.xml file. For example, if PortletA uses "lastname" and PortletB uses "surname", you can add an alias in PortletA's portlet.xml file.

The qname of the event of PortletB is "surname". This is what you'll add as an alias in PortletA's portlet.xml file. The same goes for PortletB, where you'd use the qname of the event of PortletA as the alias.

Extensibility is a crucial aspect of the Portlet Specification, allowing portal vendors to include their specific extensions.

The Portlet Specification has several mechanisms that enable extensibility, with vendor-specific properties being one of them. This allows vendors to include their own custom properties in the portlet.

Custom portlet modes are another mechanism that enables extensibility. By using custom portlet modes, vendors can provide additional functionality to the portlet.

The portal context is the key to obtaining information about a portal's supported extensions. As explained in the “Portal Context” section, the portlet can obtain this information via the portal context.

Custom window states are also a part of the extensibility mechanism. This allows vendors to provide additional window states for the portlet, giving users more flexibility.

By utilizing these extensibility mechanisms, portal vendors can provide a more tailored and user-friendly experience for their customers.

You might enjoy: Disable a Specific Website from Google Chrome Extensions

Portlet modes and window states are fully aligned between JSR 168 and WSRP, making it easier to integrate portlets across different platforms.

Both standards have user-to-portlet interaction, with the action and render phases, allowing for seamless communication between the portlet and the user.

URL encoding and creating URLs pointing to the portlet are fully aligned between JSR 168 and WSRP, making it easy to navigate between different portlet modes and window states.

State that allows the current portlet fragment to correctly display in subsequent render calls is supported in WSRP under the term navigational state and in JSR 168, with the render parameters, which can map to WSRP’s navigational state.

Here's a brief overview of the key concepts that have been aligned between JSR 168 and WSRP:

Portlet Compatibility is crucial for ensuring seamless integration between different portlet versions. This is especially true when importing JSR 286 portlets into an existing web application that contains JSR 168 portlets.

In such cases, the existing portlet.xml is upgraded to the JSR 286 schema, but JSR 168 portlets may behave differently in JSR 286. To mitigate this, JSR 168 portlets must invoke a JSR 168 compatibility mode to run under JSR 286.

There are three cases in which JSR 168 portlets will behave differently in JSR 286:

JSR 168 portlets that run in a JSR 286 container without JSR 168 compatibility mode invoked may be subject to a potential security hole through the new portlet-served resource feature in JSR 286. To prevent this, the container runtime option com.oracle.portlet.disallowResourceServing should be set to true for these portlets.

Portlets can be categorized into two main types: content portlets and action portlets. The Java Portlet Specification defines these categories.

A content portlet is responsible for displaying information to the user, such as a news feed or a list of articles. The specification provides examples of content portlets, including a simple news feed portlet that retrieves news articles from a database.

Action portlets, on the other hand, allow users to interact with the portlet, such as voting on an article or commenting on a blog post. The specification includes examples of action portlets, such as a voting portlet that updates a database with user votes.

The "Hello World" of portlet development is a simple text-based portlet that displays a message. This example is often used to introduce new developers to the world of portlets.

A "Hello World" portlet is typically created by writing a small piece of code that outputs a message to the user. This code is usually written in a programming language such as Java or JavaScript.

Portlets can be used to create a wide range of applications, from simple text-based interfaces to complex data-driven dashboards. The "Hello World" portlet is a great starting point for developers who want to learn more about portlets.

In this example, the portlet is rendered as a simple text box that displays the message "Hello World". This is a good starting point for developers who want to learn more about portlet development.

Additional reading: Golang Comments

The Weather Map Sample is a great way to understand how portlets can work together. It's a simple yet effective example of how public render parameters can be used to coordinate between different portlet applications.

The Weather portlet sets the zip code, which is a public render parameter that's supported by both the Weather and Map portlets. Any change in the value of zip by the Weather portlet is reflected during the render phase of both portlets.

Public render parameters can be tricky to work with, but aliases can help coordinate between portlets that use different identifiers. For instance, the WeatherPortlet uses zip code, while the MapPortlet uses pincode.

To add an alias, you can add the same qname of the public render parameter of one portlet in the portlet.xml file of the other portlet. This allows the portlets to coordinate with each other, even if they use different identifiers.

In the WeatherPortlet, setting the public render parameter zip-id makes it obtainable as pin-code in the MapPortlet. This is a powerful feature that can make your portlet applications more flexible and efficient.