Write portlet

xiaoxiao2021-03-06 75

This section introduces you to the concept of creating portlets, starting with a simple portlet that completely modified. Use the section of the Portlet API and Javadoc as a reference.

Creating a simple portlet instance portlet sample set portlet development environment Hello World portlet Compile Java Source package and deploy portlet generation tag Use a persistent portlet message Pass message and track record log refresh portlet cache output parallel portlet Personalization portlet

If you are familiar with WebSphere Portal Family version 2.1 Product development portlet, you should be able to note that the Portlet API has made significant improvements. See migrating portlets for more information.

Create a simple portlet instance

WebSphere Portal includes the following predefined portlets that can be found in the WP_ROOT / Install directory.

Portlet file name file server portlet, providing a static HTML file fileserverportlet.warservlet call portlet, call servlet as a portlet, ServletInvoker.warjsp portlet, serve the JSPJSPSERVERPORTLET.WARCSV viewer, display data in a comma-separated value format arranged in formatted file csv.warrss portlet Display remote URLs that provide data using rich site summary format. Xslt.warocs viewer displays the "Open Content Cindida" channel supply. OcsViewer.war

These portlets provide basic functions (such as providing static HTML services or dynamic JSP file services), so you don't have to write code to your portal. You can create and deploy any number of instances of these portlets by using the management of the portal. See Portlet management for more information.

Serve static content using the portlet file server

The portlet file server displays any HTML files in its path to the portlet window. By default, it displays Test.html in the FILESERVERPORTLET / HTML directory at the WAR file. To other content services, you can add HTML files to the path to the Portlet file server and use portlet management to modify its URL parameter to a new file in the portal management. The root of the URL parameter points to the WAS_ROOT / InstalledApps / Portlet_ID.EAR / FILESERVER.WAR directory, the portlet_id is the unique identifier created in this directory. You can create multiple portlet instances, each of which serves different content from its respective path.

Portlet sample

A set of sample portlets, which demonstrate the functionality of the Portlet API. These portlets are provided by the Bookmark_Samplets.zip file in the wp_root / dev directory. These sample portlets contain the following files:

Bookmark0.war demonstrates how to get, set and remove a specific portlet. However, this portlet does not produce any output. Bookmark1.war Write output to the portal using PortletResponse. Bookmark2.war implements listeners (for example, inserting an HTML output before the portlet tag in the page). Bookmark3.war Retrieves parameters from portletconfig and retrieves properties from PortletData and PortletSetting. Bookmark4.war gets localized text from the resource bundle. Bookmark5.war contains JSP for viewing methods for portlets. Bookmark6.war contains JSPs for editing methods and implementing ActionListener so that users add bookmarks. The following sections describe how to create a simple Hello World portlet, as well as how to compile, package, and deploy this portlet. No file samples for Hello World; you must use the examples provided in text to create it. However, HelloWorld2.War provided in the WP_ROOT / DEV directory, which demonstrates how to use JSP to provide portlet tags.

Set the portlet development environment

Before trying to discuss any classes and samples discussed in this section, you should set an environment that makes written, compile, and test portlets more easily implement. WebSphere Portal product packages include the following development tools:

WebSphere Studio Application Developer version 4.02 supports e-commerce application terminals to the development, testing and deployment of the terminal. The Portal Toolbox Portal Toolbox is inserted into the Application Developer and provides a wizard to create a portlet application project and create a portletAdApter and MVCPortlet class, as well as a template-based portlet (servletinvokerport, jspportlet, and xsltport, jspportlet, and xsltport, JSPportlet, and xsltportlet). Make sure you set your system PATH environment variable to use JDK 1.3.0, which is JDK used by WebSphere Application Server. This JDK level is required to compile class files to use in portlets.

In addition to developing workstations, the portal server should be set to publish and test your portlet application project by installing the following components:

WebSphere Portal WebSphere Application Server - Advanced Edition, Single Server

Hello World Portlet

The Hello World Portlet provides an introduction to your first portlet. Hello World Extension AbstractPortlet Heliers Class and provides a minimum way for portlet. It uses PortletResponse to provide a simple output to the portal page.

Example: Hello World Portlet

Package com.ibm.wps.samples.helloworld;

Import org.apache.jetspeed.portlet. *;

Import org.apache.jetspeed.portlets. *;

Import java.io. *;

Public Class HelloWorld Extends Abstractportletlet

{

Public void init (portletconfig portletconfig) Throws unavailableException

{

Super.init (portletconfig);

}

Public Void Service (PortletRequest portletRequest, PortletResponse portletResponse)

Throws portletException, IOException

{

PrintWriter Writer = portletResponse.getwriter ();

Writer.println ("

Hello Portal World! ");

}

Compilation Java source code

Compile the JAVA source file using the JDK provided by WebSphere Application Server. Before compiling the Java source, set the ClassPath for the compiler to find the JAR file of any portlet package used by the portlet. The following JAR files should always be set in the ClassPath to compile:

WAS_ROOT / LIB / App / Portlet-Api.jar;

WAS_ROOT / LIB / APP / WPSPORTLETS.jar;

WAS_ROOT / LIB / APP / WPS.JAR;

Where WAS_ROOT is the installation directory of WebSphere Application Server. Also, if you need any classes of the servlet function, add the following:

WAS_ROOT / LIB / J2EE.JAR;

WAS_ROOT / LIB / WebSphere.jar;

Then, compile the portlet using the fully qualified path of the Java portlet source code.

Javac-ClassPath% classpath% com.ibm.wps.samples.Helloworld.java

To test the Hello World after compiling, you must first package it into a WAR file and install it to the portal server. However, the first step is to encapsulate the portlet into a JAR file format. To create a JAR file named helloWorld.jar, enter the following command:

Jar -cf helloworld.jar HelloWorld.class

See the JDK document for more information on JAR commands.

Package and deploy portlet

After completing the development and testing portlet, the portlet is ready to deploy to the portal server in the form of a web application archive or WAR file. You also need to package your portlet into a WAR file to test it in the portal server.

The WAR file format contains Java classes and resources that make up a single portlet. The resource can be an image, a JSP file, or an attribute file that contains a message text that is translated. In addition to portlet code and resources, the WAR file also includes web application deployment descriptors (web.xml) and portlet.xml, which contains the information required to install and configure portlets. Package the portlet class, resources, and descriptive information into a single file, making the distribution and deployment of portlet easier.

WebSphere Portal contains a management portlet for installation, uninstall, and updating portlets. The benefits of containing portlets in the WAR file can be dynamically downloaded and installed. The portal administrator can download the WAR file from the Internet and then use the portal management interface to install the portlet to WebSphere Portal. The portlet is ready for use, and does not need to restart the server.

To encapsulate the portlet in the WAR file, follow these steps:

Create a deployment descriptor. Press the WAR file directory structure to arrange the portlet file. Use the JAR utility to encapsulate files.

Hello World deployment descriptor

The following samples can be encapsulated with the Hello World Portlet. See Deploying descriptors for complete information about this topic.

Web application deployment descriptor:

"http://java.sun.com/j2ee/dtds/web-app_2.2.dtd">

Hello World Portlet Application - Portlet Sample # 1

HelloWorld

com.ibm.wps.samples.HelloWorld

HelloWorld

/ helloworld / *

Portlet deployment descriptor:

"portlet_1.1.dtd">

Hello World Portlet Application - Portlet Sample # 1

HelloWorld

Concrete Hello World Portlet Application - Portlet Sample # 1

portlet master

YourId@yourDomnain.com

HelloWorld

Hello World - Sample Portlet # 1 </ Title> <title-short> hello-world </ title-short> <Description> Hello World - Sample Portlet # 1 </ description> <keywords> Portlet Hello World </ keywords> </ logage> </ concrete-portlet> </ concrete-portlet-app> </ portlet-app-def> WAR file directory structure Before encapsulating your portlet, you must arrange the class files and resources as described here. The portlet application exists as a structured directory hierarchy. / The root directory of the portlet file structure. / images The location of any image required for portlet. / Web-inf All positions of protected resources. The / web-inflicment is used to store the portlet descriptor documentation required by the package portlet, and the JAR files and classes that can be performed at all runtime. The portlet information directory is not part of the application utility document tree. The files residing in / web-infers are not directly serving clients. / Web-INF / LIB Store the location of the portlet jar file. / jsp The location of the JSP file. / Web-inf / classes The location of the portlet class file. Individual class files should be stored / WEB-INF / CLASSES is reflected in the directory structure of the class package. For example, packages Com.ibm.wps.samples.helloworld classification HelloWorld.class should be stored /Web-inf/classes/com/ibm/wps/samples/helloworld.class . / META-INF The location of the Manifest file, MANIFEST.MF. Manifest is defined for the Java 1.3 specification in the standard JAR file format. The content in / meta-infers is not serving the client. Multilingual view selection WebSphere Portal supports the internationalization of portals and portlets. Those JSPs that contain most of the text (for example, help JSP) can be directly translated. This means that the text is included in the JSP instead of the resource bundle. For JSPs that do not use the resource bundle, you need to store it to the appropriate localization. When the portlet uses JSP to the output portlet, the portal will search and select the correct JSP based on the settings of the target browser and the target browser of the country or region. To use the portletcontext.include () function to include the JSP to portlet: getPortletConfig (). GetContext (). Include (Path, PortletRequest, portletResponse); To make the portlet, you must use the following directory structure to encapsulate the portlet's JSP to the WAR file: WEB-INF / JSP / MARKUP_TYPE / LANGUAGE _COUNTRY_VARIANT /JSPNAME.JSP among them:... path The path of the developer defines. Path can't be included MIME-TYPE / Language_ Country_ Variant. The include () method has positioned the correct JSP in these directories. Markup_type Yes HTML, WML or Chtml. Language Is a language of JSP, for example EN, JA or DE. COUNTRY Is a country or region of JSP, such as US, UK or CA. Variant It means different browsers, such as IE5 or NS4. For example, if the client is used by the language characteristics, the Internet Explorer 5, method includes include (/mypath/mytemplate.jsp, portletRequest, PortletResponse) Let the portal server look for JSPs in the following order. /html/mypath/ie5/EN_us/mytemplate.jsp /html/mypath/ie5/EN/MyTemplate.jsp /HTML/mypath/ie5/mytemplate.jsp /html/mypath/en_us/mytemplate.jsp / html / mypath / en /mytemplate.jsp /html/mypath/mytemplate.jsp /html/en_us/mytemplate.jsp /html/en/mytemplate.jsp / HtML/Mytemplate.jsp /mytemplate.jsp Pack portlet and resource into the WAR file Any JAR utility can be used to build a WAR file. Here's an example of how the JAR utility provided by WebSphere Application Server. To create a WAR file named mailportlet.par and contain all files in / web-inf and / images: jar -cf helloworld.war images Web-INF To update an existing WAR file helloworld.war: jar -uf helloworld.war Web-inf / portlet.xml To extract the portlet descriptor from the WAR file helloworld.war: jar -xf helloworld.war web-inf / portlet.xml To take all the files from the existing WAR file helloworld.war: jar -xf helloworld.war Once you have created a WAR file, you can press Portlet to install it to WebSphere Portal. To make portlet applications and complex portlets easy, XML access is a portlet configuration file called for installation. Use the portlet configuration file to allow the specified location and page to place your portlets, topics, and appearances, support tags, and clients, and other settings. This is especially useful for portlets that use messages because these portlets must be placed on the same page. To get more information about XML access, see the XML input and output and the representation of the XML Mural. Generate marker In the first example, Portlets provide tags using Java PrintWriter. Most tags are generated using JSP. When the portlet must transform the XML source, there is an exception. In this case, the portlet can use the XSLT to generate tags. Use JSP to generate tags One of the easiest ways to divide the portlet marker from the main function of portlet is to use JSP. Below is a JSP for editing pages for Hello World2 samples. Separated views or help JSP will exist to provide user interfaces to support additional portlets. There are a few considerations when writing your JSP: To keep the consistency of the portal appearance, use the portlet class specification in the style sheet of the portlet. Make sure to include the JSP tag library for WebSphere Portal to get the features you need to manage the namespace of your portlet. In addition, the request parameter name is set using the <portletAPI: EncodeNameSpace> tag. See Using the Portlet API tag to get more information. In this example, the Java String object is passed to the JSP from the DoedIt () method of the portlet. For more complex data transfer, you may need to create a separate object (data view bean or hash table) to include the data required. Example: JSP for editing methods for Hello World2 <% @ Taglib Uri = "/ Web-INF / TLD / Portlet.tld" prefix = "portletApi"%> <portletapi: init /> <jsp: usebean id = "saveuri" class = "java.lang.string" scope = "request" /> <JSP: usebean id = "ca ZENLURI" class = "java.lang.string" scope = "request" /> <JSP: usebean id = "username" class = "java.lang.string" scope = "request" /> <! - build table for edit screen -> <div class = "wpseditback"> Configure Hello World portlet <form method = "post" name = "form" action = "<% = saveuri%>"> <table width = "100%" cellspacing = "0" cellpadding = "0" border = "0"> <tr> <td align = "right" class = "wpsedittext"> Enter string to display: </ td> <TD> <Input Class = "WPSEDITFIELD" SIZE = "20" TYPE = "Text" Name = "<% = portletresponse.encodenamespace (" UserName ")%>" Value = <% = Username% >> </ td> </ TR> <! - EMPTY ROW -> <tr> <TD> </ td> </ TR> <tr> <TD Class = "WPSButtonTontext"> <Input Type = "Submit" name = "save" value = "save"> <Input Type = "Button" value = "ca Zancel" OnClick = "WINDOW.LOCATION.HREF = '<% = canceluri%>"> "> </ td> </ TR> </ table> </ form> </ div> Generate tags for multiple devices One of the main features of WebSphere Portal is its support capabilities for multiple devices. WebSphere Portal supports PC browsers, I-MODE, and WAP phones, which will also support other device types in this product. The challenge to support a variety of devices is to output content in different ways according to the features of the browser. A browser accepts HTML 4.0; another acceptable WML; a WAP phone can display four lines of text, 25 characters per row; and another phone may have its own PDA-style interface. The following example demonstrates a method that selects the tag type associated with the current device before generating the portlet. DomarkUpOutput () method is provided, calling this method to handle the request for each portlet mode. The Client object acquired from PortletRequest identifies the tag language required for the current device. Example: Add method to handle different tags ... { Public void init (portletconfig portletconfig) Throws unavailableException { Super.init (portletconfig); // Call Super to do further init } Public Void DoView (PortletRequest Request, PortletResponse Response) Throws portletException, IOException { DomarkupOutput (Request, Response, "View"); } Public Void Dohelp (PortletRequest Request, PortletResponse Response) throws portletException, IOException { DomarkupOutput (Request, Response, "Help"); } Public void doedit (PortletRequest Request, PortletResponse Response) Throws portletException, IOException { DomarkupOutput (Request, Response, "Edit"); } Public void Domarkupoutput (PortletRequest Request, PortletResponse Response, String portletmodestring) throws portletException, IOException { String markup = Request.getClient (). GetMarkupname (); PrintWriter Writer = response.getwriter (); / / -------------------------------------------------------------------------------------------- ------------------------------------- // check the client device to determine the Type of Markup to generate / / -------------------------------------------------------------------------------------------- ------------------------------------- IF (Markup.Equalsignorecase ("HTML")) // Standard HTML: TEXT / HTML { Writer.println (" Hello Portal ... The portlet mode is:" portletmodestring ""); } Else IF (Markup.Equalsignorecase ("WML")) // WML: TEXT / WML { Writer.println ("<Card ID = /" Hello / "> Hello Portal ..."); Writer.println ("The portlet mode is:" portletmodestring " </ cound>"); } Else IF ("chtml") // Compact HTML: Text / HTML { Writer.println (" Hello Portal ... The portlet mode is:" portletmodestring ""); } Else // Unrecognized Markup Type Error: throw an exception { New PortletException ("Unknown Markup Type"); } } } Use the MVCPortlet class WebSphere Portal provides a part of the MVCPortlet class as part of the com.ibm.wps.portlets package. Extending the portlet of the class does not have to check the client tag before sending output. Instead, they provide controller classes for each tag type. The servlet class tag in the web application descriptor defines an empty debug file class that extends the MVCportlet. The controller class is defined as an initialization parameter, as shown in the following example. <servlet-class> com.mycompany.myportlet.mymvcportlet </ servlet-class> <init-param> <param-name> Controller.html </ param-name> <param-value> com.mycompany.myportlet.htmlController </ param-value> </ init-param> <init-param> <param-name> controller.wml </ param-name> <param-value> com.mycompany.myportlet.wmlcontroller </ param-value> </ init-param> <init-param> <param-name> Controller.chtml </ param-name> <param-value> com.mycompany.myportlet.chtmlController </ param-value> </ init-param> Controller class extension AbstractPortletController and contains portlet code, such as doView (), doedit () method or ActionListener (if necessary). Application Developers allow you to create a MVCportlet from the Creative Portlet project wizard. Persistence Save, retrieve or delete portlet data to persistence portlet data using the portletdata object. The portlet can store the value in the portletdata object when the portlet is in an edit mode. If the portlet is on the group page, the information saved in PortletData is available for all portlet users. Portlet retrieves references to the portletdata instance by calling the GetData () method of the portletRequest object. In the example of Bookmarkportlet.java to Bookmark6.war, the SetAttribute () and Store () methods save the information to PortletData after the user enters the bookmarks on the edit page. However, first retrieve the user's URL_Count from portletdata to update URL_COUNT. Portletdata Data = Event.getRequest (). GetData (); String count = (string) data.getattribute (URL_COUNT); INT i = 0; IF (count! = null) { I = integer.parseint (count); } i ; Data.setttribute (Name_PREFIX I, NAME); Data.setttribute (URL_PREFIX I, URL); Data.setttribute (url_count, integer.tostring (i)); TRY { Data.Store (); } Catch (IOException E) { Throw new portletException (e); } Only Java String types can be saved to the portletdata object. Note: Portlets (before users log in) are located in the default portal page page cannot be accessed. To prevent undesired errors on the default page, notify the administrator not to contain this portlet on the default page, or test the availability of PortletData before attempting to access its properties. PortletData is also used in Hello World2 samples, enabling users to edit greetings and save them as persistent states. In addition, PortletContext is used to call JSP to output viewing and editing tags. The default greeting to display is obtained from a Web application deployment descriptor. The following demonstrates a descriptor that sets the initialization parameter defaulthellostring to "Hello!". Example: Hello World2 Web Application Descriptor <? XML Version = "1.0" encoding = "UTF-8"?> <! DocType web-app PUBLIC "- // Sun microsystems, Inc.//dtd Web Application 2.2 // en" "http://java.sun.com/j2ee/dtds/web-app_2.2.dtd"> <web-app id = "WebApp_3"> <Display-name> Helloportlet </ display-name> <servlet ID = "servlet_1"> <servlet-name> Hello World2 </ servlet-name> <servlet-class> com.ibm.wps.samplets.helloWorld.HelloWorld2 </ servlet-clas> <init-param> <param-name> defaultHellostring </ param-name> <param-value> Hello! </ param-value> </ init-param> </ servlet> <servlet-mapping id = "servletmapping_1"> <servlet-name> Hello World2 </ servlet-name> <url-pattern> / hello world2 / * </ url-pattern> </ servlet-maping> </ web-app> <init-param> tag setting configuration data is read-only and derived for each user and the specific portlet maintenance of each portlet. If you need to allow each particular portlets to have different configurations, you should set data in the <concrete-portlet> tag of the portlet deployment descriptor. DOVIEW () method receives control before this portlet is displayed. Access the portletdata object to get the string to display. If the user has not specified the string to be displayed, the default string will be used. This string stores in the PortletRequest object, allowing it to generate JSP (ViewJSP) for this portlet. The doEdit () method receives control before the editing page is displayed for this portlet. A returned URI is created and passed to the editing method using the portletRequest object. The save operation is included in the Return URI to call an ActionListener for this portlet. The portal passes the control to the ActionListener when the save operation is processed. ActionListener can reserve "editing" information entered in the persistent memory. See Operating Events for more information on ActionListener and portlet. The code of the HelloActionListener is displayed as the following portlet code. Example: Save and retrieve data from portletconfig Package com.ibm.wps.samplets.helloworld; Import org.apache.jetspeed.portlet.defaultportletAction; Import org.apache.jetspeed.portlet. *; Import org.apache.jetspeed.portlet.event. *; Import org.apache.jetspeed.portlets. *; Import java.io. *; Import java.util. *; Public class helloworld2 extends abstractportlet loading informationListener { // Since there is a single instance of the portlet, only use instance variables, ONLY USE INSTANCE VARIABLES // for Immutable Values That Are The Same for All Users of the portlet Private final static string viewjsp = "/web-inf/helloWorld/html/helloWorldView.jsp"; Private final static string editjsp = "/web-inf/helloWorld/html/helloworldedit.jsp"; PRIVATE STRING DEFAULTSTSTRING Public void init (portletconfig portletconfig) Throws unavailableException { Super.init (portletconfig); IF (getPortletLog (). IsDebugeNabled ()) { GetPortletLog (). Debug ("HelloWorld: Init Called); } // the default hello string is Obtained from the portlet configuration parameters DefaultString = PortletConfig.getinitParameter ("defaulthellostring");} Public Void DoView (PortletRequest Request, PortletResponse Response) Throws portletException, IOException { // Get the user's name to display from Persistent Storage PortletData portletdata = request.getdata (); String stringtodisplay = (string) portletdata.getattribute ("UserName"); // if this is the first time the user has accessed this portlet, the // No Display String Will Be Found for this User In Persistent Storage IF (StringTodisplay == Null) { Stringtodisplay = defaultstring; // set default string } // add the display string to the portlet request to make it it it accessible by the view jsp Request.setattribute ("UserName", StringTodisplay; // Get a context for the capital session for invoking the jsp PortletContext Context = getPortletConfig (). GetContext (); Context.include (Viewjsp, Request, Response); } Public void doedit (PortletRequest portletRequest, PortletResponse portletResponse) Throws portletException, IOException { // Create the return uri for the edit page Portleturi Returnuri = portletResponse.createreeturnuri (); // Preserve the Cancel Uri in The Request to make it it accessible by The Edit JSP PortletRequest.setttribute ("Canceluri", Returnuri.toString ()); // for the "save" Button The Return Uri Must Include The "Save" Action // so the action listener for this portlet will be invoked PortletAction SaveAction = New DefaultPortletAction ("save"); Returnuri.Addction (SaveAction); // Preserve the Save Uri in The Request to make it it accessible by The Edit JSP PortletRequest.setttribute ("Saveuri", Returnuri.toTostring ()); // Get The user's name to display from Persistent Storage String stringtodisplay = (string) portletRequest.getdata (). GetAttribute ("UserName"); IF (StringTodisplay == Null) { Stringtodisplay = defaultstring; // None Found, Set Default String } // add the display string to the request to make it it accessible by The Edit JSP // as an inital value of the input field on the Edit Form PortletRequest.setttribute ("UserName", StringTodisplay; // Get a context for the capital session for invoking the jsp PortletContext Context = getPortletConfig (). GetContext (); Context.includ (EditJSP, PortletRequest, PortletResponse); } Public void actionPerformed (ACTIONEvent Event) { DEFAULTPORTLETACTION Action = (DefaultportletAction) Event.getAction (); HelloWorld2 Helloportlet = (HelloWorld2) Event.getPortlet (); PortletLog log = helloportlet.getportletlog (); // if this is a save action, the see if the user specified a name IF (Action! = null) { IF (Action.getName (). Equals ("Save")) { PortletRequest Request = event.getRequest (); Portletdata portdata = request.getdata (); String Username = Request.getParameter ("UserName"); Try { // save the name specified by the user IF (username! = NULL) { PortData.setttribute ("UserName", UserName; Portdata.store (); } } catch (accessdeniedException ad) { } catch (ioexception ie) { Log.Error (" couldn't Write the user Date to Persistence Because An I / O Error Occurred. "); } } } } } As mentioned earlier, the Hello World2 Portlet implements an actionListener to handle the save operation. The user enters the name on the edit page, and the actionListener's actionPerformed () method obtains a string of a particular user from the portletRequest object to store the user's persistent memory. ActionListener is called before returning to the portlet, so if the user enters the name fails, ActionListener can force portlet to keep in editing, waiting for input from the user. Portlet message delivery Portlet API supports messaging between portlets on a page. For example, if four portlets (LEFT, RIGHT, TOP, BOTTOM) are part of the portlet application called Side, the portlet LEFT sends information to the portlet Right, TOP, and BOTTOM (as long as they are on the same page of the user). The following conditions are applied to the portlet of sending and receiving messages. Portlets must be on the same page. You can use XML access to the portlet application to create a portlet configuration file, which configures the portlet on the page within the installation time. Please refer to the portal configuration interface for more information. Portlets must be part of the same portlet application. This condition is only applied to portlets that implement the portletMessage interface. The portlet of the extension DefaultPortletMessage does not have to be a member of the same portlet application. Portlets deployed as a Web service cannot send and receive messages. Typically, the message is sent from the portlet's operation listener and is received by another portlet message listener. The user performs operations in a portlet. Capture and handle operational events. According to this result, the portlet can send the message to other portlets using the Send () method of the portletContext object. Example: ActionListener sent by sending a message ... Public void actionPerformed (ACTIONEvent Event) { ... IF (action.getname (). Equals ("browse")) { Log.debug ("BookmarkActionListener - Browse Action"; String URL = (String) action.getParameters (). Get ("URL"); Log.debug ("BookmarkPortletActionListener - Opening Link:" URL); ... Try { Portlet.getConfig (). getContext (). Send (Null, New DefaultPortletMessage (URL)); } Catch (AccessdeniedException ADE) { Log.Error ("BookmarkportletActionListener - Unable to send message /" url = " url " / "- accessdenated"); } } ... } In this sample, "Browse" operation has been defined in the bookmark portlet. DefaultPortletAction BrowseAction = new org.apache.compeed.portlets.defaultportletAction ("browse"); browseaction.addparameter ("URL", URL); Portleturi portleturi = response.createreturnuri (); Portleturi.Addaction; String actionuri = portleturi.toString (); The Send () method uses the following own variables: Portletname Receive the requested portlet name. In the above example, send the message to Null, which means it broadcasts all portlets in the same portlet application. To send a message to a specific portlet, specify the name of the portlet, just as defined in the <portlet-name> tag in the portlet deployment descriptor. news The message to send. Message must be the interface PortletMessage object or any subclass. In the above example, the message is DEFAULTPORTLETMESSAGE object exemplifies, containing URL string. The portlet received has a message listener that retrieves the message using the getMessage () method of the message event. Example: Messagelistener, received message Public void MessageReceived (MessageEvent Event) Throws portletException { PortletMessage Msg = event.getMessage (); IF (MSG InstanceOf DefaultPortletMessage) { String Url = (DefaultportletMessage) msg) .getText (); PortletApterapter portlet = (portletadapter) Event.getPortlet (); Portlet.getPortletLog (). Debug ("BookmarkPortletMessageListener MessageReceiVed"; PortletRequest Request = event.getRequest (); PortletSession session = request.getations (); Session.SetAttribute ("URL", URL); } } } Since MessageListener sets the received message as a session attribute, the portlet that is receiving must obtain the "URL" parameter from the session. For more information on operating events and message events, see the portlet event. Message and track record log Portlets can write messages and tracking information to log files, which maintained in WP_ROOT / LOG / directory. The log file helps the portal administrator review portlet errors and special circumstances and helps the portlet developer test and debug portlet. Portlet API provides a PortletLog class, which writes messages and tracking information to logs: Debug () Write track information to WPS_ [TimeStamp] .log. INFO () Write the information news WPS_ [TimeStamp] .log. Error () Write the error message WPS_ [TimeStamp] .log. Warn () Write a warning message WPS_ [TimeStamp] .log. [TimeStamp] format is as follows: Year.Month.date-Hour.minute.second For example: WPS_2002.03.08-14.00.00.log is written at 2:00 pm March 8, 2002. If you have access to the portlet log multiple times in a method, it is recommended to specify the log reference to the variable, for example: Private portletlog mylogref = getPortletLog (); Since the log operation is high, PortletLog provides a way to determine if the log is enabled for a given level. Your portlet is written to a given level only when the log is tracking the level of message. E.g: IF (getPortletLog (). IsdebugeNabled ()) { MYLOGREF.DEBUG ("Warning, Portlet Resources Are Low!"); } To get more information about logs in WebSphere Portal, see Log Management. Refresh portlet cache Portlet cache keeps the full output of the portlet. As a result, when the user changes the portlet state, the portal server does not call the portlet's service () or DOVIEW () method. When the cache entry of the current portlet should be invalid, the getLastModified () method makes the portlet developer to notify the container, so you should refresh the content of the portlet. You can use WindowListeners to set up new timestamps and return timestamp in GetLastModified. The following example shows the part of the bookmark portlet that the bookmark caches its output, but if the window status is changed to provide other output, you will need to change its content immediately. First, in the portlet deployment descriptor, register the WindowListener and the supported portlet status and enable cache. GetLastModified () sample: portlet deployment descriptor <listener> <listener-class type = "window"> com.mycompany.portlets.bookmark.bookmarkportletwindowlistener </ listener-class> </ listener> <cache> <expires> -1 </ expires> <shared> no </ shared> </ cache> <allows> <maximized /> <minimized /> </ allows> Next, WindowListener sets timestamp for the Last_Modified property for the portlet session. GetLastModified () Example: WindowListener Package com.mycompany.portlets.bookmark; Import org.apache.jetspeed.portlets. *; Import org.apache.jetspeed.portlet. *; Import org.apache.jetspeed.portlet.event. *; Import java.io.ioException; // java stuff Public Class BookmarkportletWindowListener Extends WINDOWADAPTER { Public Void WindowMaximized (WindowEvent Event) THROWS portleTexception { SetLastModified (Event); } Public void windowRestored (WindowEvent Event) Throws portletException { SetLastModified (Event); } Private void setlastmodified (windowevent event) { PortletSession session = event.getRequest (). Getsession (false); IF (session! = null) { Session.SetaTRibute (Bookmarkportlet.last_modified, new long (system.currenttimemillis); } } Public void windowdetached (WindowEvent Event) throws portletException { } } Finally, when a request is issued, the GetLastModified () method of the portlet returns the timestamp. GetlastModified () example: Bookmarkportlet Public long getlastmodified (portletRequest request) { PortletSession session = request.getsession (false); IF (session! = null) { Long lastmodified = (long) session.getattribute (Last_Modified); IF (LastModified! = null) { Return LastModified.longValue (); } } Return -1; } Output parallel portlet By default, the portal server outputs into the portlet to the page (using separate processing thread). Administrators can set a certain number of threads or off the capability for portlet output, making it possible to use single-threaded serial output portlets. These settings are in the JetSpeedResources.properties file. See Managing portlets in the portal parallel output for more information. Also set portlet output at the portlet level, which is off. To set parallel portlets for the portlet, set the configuration parameters in the <Concrete-Portlet> tag of the portlet deployment descriptor. <config-param> <param-name> Parallel </ param-name> <param-value> True </ param-value> </ config-param> Setting this parameter in portlet.xml to help administrators avoid setting up the portlet. Personalized portlet WebSphere Personalization enables customers to easily build a Web site, so that the site content matches site visits. Although customization allows users to set their own preferences or determine what content, portal vendors (developers, administrators) use personalization to determine what is displayed based on user characteristics. All personalized solutions have user concept, content, and matching technology. WebSphere Portal provides user concept, which is implemented as a User class with user profiles. For each installed portal content is specific and can include customer data storage, old database, subscription content providers, and others. For matching technologies, WebSphere Personzalization provides a rule-based personalized resource engine and rule engine. Combined with these components allow you to develop portlets with personalized rules that match users. Consider an example of an internal web portal for purchasing office supplies. More than $ 50 orders must be approved by the manager. When the portlet user is a manager, the portlet needs to display a button that launches the approved form. In this case, the button can be added to the view JSP of the portlet as the content point. The content point is where you want to display a web page of personalized content. Then create the rules that map this point to the portlet user, for example: When the user is a manager, the approve button is displayed. WebSphere Studio Application Developer V4.03 is used to create content points in the Portlet JSP. The Personalization workspace is used to develop rules that display content in the user-characteristic-based point. About using a more detailed description developed by personalized portlet, you can find it in the WP_ROOT / DEV directory of the portal server. Related Information Portal configuration log management change appearance</div><div class="text-center mt-3 text-grey"> 转载请注明原文地址:https://www.9cbs.com/read-93139.html</div><div class="plugin d-flex justify-content-center mt-3"></div><hr><div class="row"><div class="col-lg-12 text-muted mt-2"><h2 class="h6 mb-0 small"><a class="text-secondary" href="tag-2.html">9cbs</a></h2></div></div></div></div><div class="card card-postlist border-white shadow"><div class="card-body"><div class="card-title"><div class="d-flex justify-content-between"><div>New Post(0) </div><div></div></div></div><ul class="postlist list-unstyled"> </ul></div></div><div class="d-none threadlist"><input type="checkbox" name="modtid" value="93139" checked /></div></div></div></div></div><footer class="text-muted small bg-dark py-4 mt-3" id="footer"><div class="container"><div class="row"><div class="col">CopyRight © 2020 All Rights Reserved </div><div class="col text-right">Processed: 0.033, SQL: 9</div></div></div></footer><script src="./lang/en-us/lang.js?2.2.0"></script><script src="view/js/jquery.min.js?2.2.0"></script><script src="view/js/popper.min.js?2.2.0"></script><script src="view/js/bootstrap.min.js?2.2.0"></script><script src="view/js/xiuno.js?2.2.0"></script><script src="view/js/bootstrap-plugin.js?2.2.0"></script><script src="view/js/async.min.js?2.2.0"></script><script src="view/js/form.js?2.2.0"></script><script> var debug = DEBUG = 0; var url_rewrite_on = 1; var url_path = './'; var forumarr = {"1":"Tech"}; var fid = 1; var uid = 0; var gid = 0; xn.options.water_image_url = 'view/img/water-small.png'; </script><script src="view/js/wellcms.js?2.2.0"></script><a class="scroll-to-top rounded" href="javascript:void(0);"></a><a class="scroll-to-bottom rounded" href="javascript:void(0);" style="display: inline;"></a></body></html><script> var forum_url = 'list-1.html'; var safe_token = '3wg3kVGaF4dhnCUTamKn93Kk08_2BfuIzOCy_2BS_2F27ygmieJv7MtZMkj_2BofekX_2FmBphnXVKE6d3ZGs4oXafVBPXVQ_3D_3D'; var body = $('body'); body.on('submit', '#form', function() { var jthis = $(this); var jsubmit = jthis.find('#submit'); jthis.reset(); jsubmit.button('loading'); var postdata = jthis.serializeObject(); $.xpost(jthis.attr('action'), postdata, function(code, message) { if(code == 0) { location.reload(); } else { $.alert(message); jsubmit.button('reset'); } }); return false; }); function resize_image() { var jmessagelist = $('div.message'); var first_width = jmessagelist.width(); jmessagelist.each(function() { var jdiv = $(this); var maxwidth = jdiv.attr('isfirst') ? first_width : jdiv.width(); var jmessage_width = Math.min(jdiv.width(), maxwidth); jdiv.find('img, embed, iframe, video').each(function() { var jimg = $(this); var img_width = this.org_width; var img_height = this.org_height; if(!img_width) { var img_width = jimg.attr('width'); var img_height = jimg.attr('height'); this.org_width = img_width; this.org_height = img_height; } if(img_width > jmessage_width) { if(this.tagName == 'IMG') { jimg.width(jmessage_width); jimg.css('height', 'auto'); jimg.css('cursor', 'pointer'); jimg.on('click', function() { }); } else { jimg.width(jmessage_width); var height = (img_height / img_width) * jimg.width(); jimg.height(height); } } }); }); } function resize_table() { $('div.message').each(function() { var jdiv = $(this); jdiv.find('table').addClass('table').wrap('<div class="table-responsive"></div>'); }); } $(function() { resize_image(); resize_table(); $(window).on('resize', resize_image); }); var jmessage = $('#message'); jmessage.on('focus', function() {if(jmessage.t) { clearTimeout(jmessage.t); jmessage.t = null; } jmessage.css('height', '6rem'); }); jmessage.on('blur', function() {jmessage.t = setTimeout(function() { jmessage.css('height', '2.5rem');}, 1000); }); $('#nav li[data-active="fid-1"]').addClass('active'); </script>