Dilip's Blogs

Portlets deployed with EAR file are not available in portal server

2014-04-30T11:55:00.003-07:00

We usually deploying portlets on portal server and we know portal server always takes WAR file. Now we are working on business applications where we do not have only portlets. We have EJBs, JSP components, WCM plugins, custom workflows along with portlets.

So keeping WAR file separate with other components is not a better idea. It is better to keep EAR file on WAS which will help us to deploy everything at one go.

Now we have some observations that deployment with EAR file is not reflecting portlets on portal environment. We got one thing that deployment of WAR file with portlets are reflecting portlets on portal environment but EAR with portlets and other components are not reflecting portlets on portal environment.

This is happening since WAR deployment store portlets entry in portal DB but EAR deployment is not storing that entry.

So applying this entry, we need to apply XML file on portal server. This will make available portlets on portal server.

You will find reference links with following links,
http://publib.boulder.ibm.com/infocenter/wpdoc/v6r0/index.jsp?topic=/com.ibm.wp.ent.doc/wps/adprdplt.html

http://wpcertification.blogspot.in/2009/03/installing-portlet.html

There is one more thing which I would like to share,
when we apply XML on portal server, immediately WAR file [part of EAR] is available in portal server environment.
In case, you want to update any specific portlet, you can delete WAR file in portal environment and apply XML file again otherwise use 'update' [instead of 'create'] in XML file and apply on portal server.

IBM portal 8 impersonation feature

2013-06-25T11:50:00.000-07:00

IBM portal 8 has come up with latest feature which saves lot of time for developers. I had worked one of JEEE project in which I have used impersonation feature. For achieving this feature, J2EE developers are using too much code and testing efforts.

I would like to describe in brief about impersonation feature for those who do not know about this. This feature is used to replicate the end user screen to understand the issue of end user.
Suppose user X has some issue in his web-site (using X's credentials). He raised request for web-site administrator and explained about his issue. For understanding the issue of user X, administrator will impersonate the screen of User X and will try to replicate the issue without informing user X.
This feature is useful to understand the end user functionality or support.

IBM portal 8 provides this feature by default in portal server.

Keep tracking of this blog... I will add more post on portal new features which beats the market of other portal servers.

Render parameter key or value must not be null or values be an empty array.

2011-12-10T02:18:00.001-08:00

This error occurs when we store render parameters in Java Array. Generally, we store all the render parameters in separate Java String object which are working perfectly fine.

I tried this once with Java Array when I have more than 10 render parameters. I received the same error mentioned in subject line of post. The complete line of error is,

java.lang.IllegalArgumentException: Render parameter key or value must not be null or values be an empty array.

This issue occurred due to internal implementation of this method. It returns the value of a request parameter as a String, or null if the parameter does not exist.

If I try the line below for receiving render parameter, we will receive the same error.

String[] arrUserDetails1 = new String[2];
arrUserDetails[0] = request.getParameter("txtUserName");

If I try the line below for recieving render parameter, This will be working fine.

String[] arrUserDetails1 = new String[2];
String userName = request.getParameter("txtUserName");
arrUserDetails[0] = userName;

The conclusion is, render parameters can not store in to empty java array.

Portlet namespace

2011-10-01T07:20:00.000-07:00

First, I would like to highlight some point for those who are new in portal and they are not aware of namespaces.

Basically 'namespace' term is used in portal terminology and this term comes from portal itself. Let me clear this point in easy way. Suppose, we have a large amount of data in database and we want to fetch a particular data from database. So what we will do? We would need a unique id for identifying the data which you want to fetch.

In a same way, portal manages all portlets with a unique id that called 'namespace'. I think, I am able to describe this think in simpler way.

Now the question is, if namespace is unique for each portlet so what happen if we use different instance of same portlet on a same page. The answer is, portal creates different namespaces for different instances.

Ok, this is with a single user. What happens if we use the same instances (2 instances on same page) with other user. This is a tricky question if you do not know. Here the answer is, namespaces are similar for other user.

Conclusion

In portal server, namespaces are managed according to portlet instances. Namespaces are changed according to instances of portlet, these are not changed with change user (i.e. other users).

Portlet request dispatcher inclusion error MXParserFactory not found

2011-05-04T11:51:00.000-07:00

I would like to share one more experience which I have had with Web services API used with portal environment (using portlets). In this, I prepared a Java Client (Stub) using Axis2 1.5 tool which contains Java classes and XML files. While compiling this code, I faced some issues. At first, I found an error which is,

4/21/11 20:08:58:000 IST] 00000052 PortletReques E com.ibm.ws.portletcontainer.

core.impl.PortletRequestDispatcherImpl internal include EJPPC0172E: Error occurred during portlet request dispatcher inclusion
                                 java.lang.NoClassDefFoundError: javax.xml.stream.XMLStreamException
    at java.lang.J9VMInternals.verifyImpl(Native Method)
    at java.lang.J9VMInternals.verify(J9VMInternals.java:68)
    at java.lang.J9VMInternals.initialize(J9VMInternals.java:129)
    at com.yash.ews.connection.EWSBaseConnector.(EWSBaseConnector.java:113)

The resolution of the error is to set JSR173_API.jar in lib directory of your application. Your compile time issues will get resolved. Once you run this application, you will get another error which is,

[4/21/11 20:12:58:232 IST] 00000055 PortletReques E com.ibm.ws.portletcontainer.

core.impl.PortletRequestDispatcherImpl internal include EJPPC0172E: Error occurred during portlet request dispatcher inclusion
                                 javax.xml.stream.FactoryConfigurationError: Provider com.bea.xml.stream.MXParserFactory not found
    at javax.xml.stream.FactoryFinder.newInstance(FactoryFinder.java:72)
    at javax.xml.stream.FactoryFinder.find(FactoryFinder.java:176)
    at javax.xml.stream.FactoryFinder.find(FactoryFinder.java:92)
    at javax.xml.stream.XMLInputFactory.newInstance(XMLInputFactory.java:136)
    at org.apache.axiom.om.util.StAXUtils$7.run(StAXUtils.java:505)
    at java.security.AccessController.doPrivileged(AccessController.java:197)
    at org.apache.axiom.om.util.StAXUtils.newXMLInputFactory(StAXUtils.java:495)
    at org.apache.axiom.om.util.StAXUtils.getXMLInputFactory_perClassLoader(StAXUtils.java:566)
    at org.apache.axiom.om.util.StAXUtils.getXMLInputFactory(StAXUtils.java:172)
    at org.apache.axiom.om.util.StAXUtils.getXMLInputFactory(StAXUtils.java:137)
    at org.apache.axiom.om.util.StAXUtils.createXMLStreamReader(StAXUtils.java:224)
    at org.apache.axiom.om.util.StAXUtils.createXMLStreamReader(StAXUtils.java:218)
    at org.apache.axis2.util.XMLUtils.toOM(XMLUtils.java:596)
    at org.apache.axis2.util.XMLUtils.toOM(XMLUtils.java:581)

This error is related with XML parser. In java, we are aware of SAX parser however there is another parser StAX which is now used in latest programs and has the option of pausing and resuming the parsing process. Also works in similar streaming fashion. You can find this parser in sjsxp.jar which resolve this issue.

You can get more knowledge for the same in StAX.

HTTPSender Unable to sendViaPost to url

2011-04-22T09:06:00.000-07:00

I would like to share one of my experience which I have had with Web services API used with portal environment (using portlets). In this issue, what I found is, the issue is not related to Web services, XML and portal. This error occurs due to invalid certificate which is used in portal environment. The main cause of this issue is, you are preparing request for HTTPS URL and your portal is not using valid certificate. So what you need to do is? update your certificate and restart your App server and portal server (depending on your environment). Your issue will get resolved. Alternatively, if you do not want to update your certificate you would need to change the configuration of server for which you have prepared URL. In my case, I am preparing URL for Exchange server (from portal) and the URL is,

https://<Exchange server host>/EWS/exchange.asmx

So you need to change your Exchange server configuration for HTTP (URL would be start from HTTP not with HTTPs).

For your information, the error details are,

[4/21/11 20:04:30:081 IST] 00000055 HTTPSender I org.apache.axis2.transport.

http.HTTPSender sendViaPost Unable to sendViaPost to url[https://<Exchange server host>/EWS/exchange.asmx]
                                 org.apache.axis2.AxisFault
    at org.apache.axis2.AxisFault.makeFault(AxisFault.java:430)
    at org.apache.axis2.transport.http.SOAPMessageFormatter.writeTo(SOAPMessageFormatter.java:83)
    at org.apache.axis2.transport.http.AxisRequestEntity.writeRequest(AxisRequestEntity.java:84)
    at org.apache.commons.httpclient.methods.EntityEnclosingMethod.writeRequestBody(EntityEnclosingMethod.java:495)
    at org.apache.commons.httpclient.HttpMethodBase.writeRequest(HttpMethodBase.java:1973)
    at org.apache.commons.httpclient.HttpMethodBase.execute(HttpMethodBase.java:993)
    at org.apache.commons.httpclient.HttpMethodDirector.executeWithRetry(HttpMethodDirector.java:397)
    at org.apache.commons.httpclient.HttpMethodDirector.executeMethod(HttpMethodDirector.java:170)
    at org.apache.commons.httpclient.HttpClient.executeMethod(HttpClient.java:396)
    at org.apache.commons.httpclient.HttpClient.executeMethod(HttpClient.java:346)
    at org.apache.axis2.transport.http.AbstractHTTPSender.executeMethod(AbstractHTTPSender.java:557)
    at org.apache.axis2.transport.http.HTTPSender.sendViaPost(HTTPSender.java:199)
    at org.apache.axis2.transport.http.HTTPSender.send(HTTPSender.java:76)
    at org.apache.axis2.transport.http.CommonsHTTPTransportSender.writeMessageWithCommons(CommonsHTTPTransportSender.java:400)
    at org.apache.axis2.transport.http.CommonsHTTPTransportSender.invoke(CommonsHTTPTransportSender.java:225)
    at org.apache.axis2.engine.AxisEngine.send(AxisEngine.java:438)
    at org.apache.axis2.description.OutInAxisOperationClient.send(OutInAxisOperation.java:402)
    at org.apache.axis2.description.OutInAxisOperationClient.executeImpl(OutInAxisOperation.java:229)
    at org.apache.axis2.client.OperationClient.execute(OperationClient.java:165)
    at com.microsoft.schemas.exchange.services._2006.messages.ExchangeServicesStub.findFolder(ExchangeServicesStub.java:8788)
    at com.yash.ews.FindFolders.findFolders(FindFolders.java:81)

Creating Web services

2011-04-01T23:21:00.000-07:00

As we all know, it's time to move on Web services. It provides a way of communication over network using two electronic devices.

Well, I had a chance in my project where I was consuming .NET Web services. At that time I was not aware of, how can I prepare my own Web services? Now I come to know the required steps for preparing .NET Web services and I am sharing the same to this post.

Steps to create Web services

As I am going to create .NET Web services for which I need to use a .NET tool which is Microsoft Visual Studio 2005.

In order to create a new web service in VS 2005, please follow the steps below,

The figure below shows you the starting page of VS 2005.

Go to File >> New >> Web Site as,

Select ASP.NET Web Services and click OK.

You will get Services.cs file which you can see in VS 2005. Here you can add your web methods which is similar as public method of your Java classes. Here I have created one 'HelloWorld' web method which you can see in Web service.

You need to debug this code. Click the green arrow button in upper middle portion of VS screen. You will get the below pop up message .

You can see your service in browser with supported operations. As I have prepared this service for HelloWorld operation, you can see the same in figure below.

You can now check your operation by clicking the same and check the used soap messages which is interacting with Web service.

As you can see in above figure, there is an invoke button. Once you click on this button, the web method will execute and give the result which you have passed in 'HelloWorld' web method in Services.cs file.

These are the steps for checking your operations which you have applied on Web services. Now you need to check your Web service which you can find in browser when you append '?WSDL' at the end of service URL which is, http://localhost:TestWebSite/Service.asmx?WSDL.

This is what I am trying to explain you. Now you need to save this file in form .wsdl.

In this way, you can prepare your own services. Also you can go through one of my post Exchange Web services Java Stub to know about Java stub (Client) creation using Axis tool and Eclipse IDE.

Exchange Web services Java Stub

2011-03-28T11:45:00.000-07:00

This post illustrates, how to create Java stub using Exchange Web services. Generally stub creation is an easy process since it is available in most of the IDE (Integrated development environment) and you need to use some clicks on IDE and you will get stub (Java source files) available in IDE.
As of My experience which I have had with Exchange Web services, it is not an easy approach. I had passed around 14 working days to get right Java stub. Here, I am sharing my experience and trying to cover all points which are required for preparing Java stub.

Required software for creating Java Stub

Eclipse Java EE IDE 1.2.0 (Galileo)
JDK 1.6
Axis2 eclipse code generation plugin

Configuring Axis2 tool for Eclipse

Download ZIP file named 'axis2-eclipse-codegen-plugin-1.5.4.zip', unzip it and copy the JAR file (inside UNZIP folder) named 'org.apache.axis2.eclipse.codegen.plugin_1.5.4.jar’ inside ‘plugins’ folder of Eclipse.
Restart Eclipse IDE.

Download Exchange 2007 Web-services

Exchange server provides three XML files which are required for preparing client stub. These files are,

Services.wsdl- Describes the contract between client and server.
Messages.xsd- Defines the request and response SOAP messages.
Types.xsd- Defines the elements that are used in the SOAP messages.

Use the URLs below for downloading these files,

<protocol>://<exchange dns="" fully="" qualified="" server="">:<exchange port="" server="">/EWS/Services.wsdl
<protocol>://<exchange dns="" fully="" qualified="" server="">:<exchange port="" server="">/EWS/messages.xsd
<protocol>://<exchange dns="" fully="" qualified="" server="">:<exchange port="" server="">/EWS/types.xsd

Examples are,

https://<Exchange server host>/EWS/Services.wsdl
https://<Exchange server host>/EWS/messages.xsd
https://<Exchange server host>/EWS/types.xsd

Download files from above links and save it by names. The names are,

services.wsdl
messages.xsd
types.xsd

Changes needed in Services.wsdl and types.xsd file

Add the below lines of code in Services.wsdl file just above the last line i.e.

<wsdl:service name="ExchangeServices">
<wsdl:port name="ExchangeServicePort" binding="tns:ExchangeServiceBinding">
<soap:address location="https://<Exchange server host>/EWS/Exchange.asmx"/>
</wsdl:port>
</wsdl:service>

In these lines, you can change following attribute according to your requirement. These are,

wsdl service name.
wsdl port name.
soap location: Represents Exchange.asmx location of Exchange server.

In types.xsd file, you need to change the definition of element which is used for updating the Exchange server's item. You need to change 'Path' definition to 'FieldURI'. This changes are recommendation by MSDN in which we should pass FieldURI instead of Path in update process.

Steps used with Eclipse

Start Eclipse and create a Java project.

Create a ‘wsdl’ folder inside project and copy the Web-services files which you have downloaded in previous point.

Create a ‘lib’ folder inside project and copy following JARS.

axiom-api-1.2.10.jar
axiom-dom-1.2.10.jar
axiom-impl-1.2.10.jar
axis2-adb-1.5.4.jar
axis2-adb-codegen-1.5.4.jar
axis2-codegen-1.5.4.jar
axis2-java2wsdl-1.5.4.jar
axis2-jibx-1.5.4.jar
axis2-kernel-1.5.4.jar
axis2-transport-http-1.5.4.jar
axis2-transport-local-1.5.4.jar
axis2-xmlbeans-1.5.4.jar
bcel-5.1.jar
commandline.jar
commons-codec-1.3.jar
commons-fileupload-1.2.jar
commons-httpclient-3.1.jar
commons-logging-1.1.jar
geronimo-jta_1.1_spec-1.1.jar
geronimo-ws-metadata_2.0_spec-1.1.2.jar
httpcore-4.0.jar
javax.mail-1.3.3.01.jar
jaxen-1.1.1.jar
jibx-bind-1.2.1.jar
jibx-run-1.2.1.jar
log4j-1.2.14.jar
mail.jar
neethi-2.0.4.jar
regexp-1.2.jar
servlet-api-2.3.jar
woden-api-1.0M8.jar
woden-impl-dom-1.0M8.jar
wsdl4j-1.6.2.jar
xalan-2.7.0.jar
xercesImpl-2.8.1.jar
xmlbeans-2.3.0.jar
XmlSchema-1.4.3.jar

Project directory structure is shown below.

Right click on project and click File -> New -> Other -> Axis2 Wizards -> Axis2 Code Generator.

Locate ‘Services.wsdl ‘ file and click ‘Next’ button.

Fill the options page in Axis2 Codgen Wizard as Figure below. Select the options carefully mentioned as figure below,

Set the output location of code which is generated by Axis2 tool. Select the options carefully mentioned as figure below.

Finally, you will receive below message if everything is fine.

All operation completed.

There are some nice links which I have used for Java stub creation.

Axis2_Codegen_Wizard_1.4.0 : Solution for issue of stub creation.
Axis2 code generation : Code Generator Wizard Guide for Eclipse Plug-in
Axis2 Stub creation error : org.apache.axis2.AxisFault: Transport error: 401 Error: Unauthorized.

Web services basics

2011-03-26T07:42:00.000-07:00

Introduction

In this topic, I am going to describe some basics of Web-services which needs to understand if you are planning development on Web-services. My main intention is to keep good contents on this post which I found from different notes.

The term Web Services refers to the technologies that allow for making connections. Also Services are what you connect together using Web Services. A service is the endpoint of a connection. The combination of services - internal and external to an organization - make up a service-oriented architecture.
For example:

VB.NET application can talk to JAVA Web-services and vice versa.
Inventory Web-service can talk to transport Web-service.

There are some nice links for understanding Web services basics and its specifications in detail.

Webo Pedia - Understanding Web Services.
Rose India - Quick introduction to web services
Tutorials Point - Web Services.
Service Architecture - Web Services explained.
Programming Web services - Web Service Tutorial.

About Web-services

Web Services allows you to expose the functionality of your existing code over the network. Once it is exposed on the network, other application can use the functionality of your program.
A Web service is a unit of managed code that can be remotely invoked using HTTP, that is, it can be activated using HTTP requests.
A Web service contains some number of classes, interfaces, enumerations and structures that provide black box functionality to remote clients.
In each case, the client indirectly interacts with the Web service through an intervening proxy or client stub. The proxy looks and feels like the real remote type and exposes the same set of methods. Under the hood, the proxy code really forwards the request to the Web service using standard HTTP or optionally SOAP messages.

Why we use Web-services?

DCOM clients access remote COM types using tightly coupled RPC calls. CORBA requires the use of tightly coupled protocol referred to as Internet Inter-ORB Protocol (IIOP), to activate remote types. Enterprise JavaBeans (EJBs) requires a Remote Method Invocation (RMI) Protocol and by and large a specific language (Java).Thus each of these remote invocation architectures needs proprietary protocols, which typically require a tight connection to the remote source.
Web services using nothing but HTTP. Of all the protocols in existence today, HTTP is the one specific wire protocol that all platforms tend to agree on.
using Web services, a Web service developer can use any language he wish and a Web service consumer can use standard HTTP to invoke methods a Web service provides. Simple Object Access Protocol (SOAP) and XML are also two key pieces of the Web services architecture.

Web Service Standards

Web services are registered and announced using the following services and protocols.

Universal Description, Discovery, and Integration (UDDI) -- is a protocol for describing available Web services components. This standard allows businesses to register with an Internet directory that will help them advertise their services.

Simple Object Access Protocol (SOAP) -- is a protocol for initiating conversations with a UDDI Service. SOAP makes object access simple by allowing applications to invoke object methods or functions, residing on remote servers. SOAP application creates a request block in XML, supplying the data needed by the remote method as well as the location of the remote object itself.

Web Service Description Language (WSDL) --, the proposed standard for how a Web service is described, is an XML-based service IDL (Interface Definitition Language) that defines the service interface and its implementation characteristics. WSDL is referenced by UDDI entries and describes the SOAP messages that define a particular Web service.

ebXML (e-business XML) -- defines core components, business processes, registry and repository, messaging services, trading partner agreements, and security.

Implementing Web Services

Here comes a brief step-by-step on how a Web service is implemented.

A service provider creates a Web service. Please go through one of my post How to create Web services using MS-Visio for creating Web services.
The service provider uses WSDL to describe the service to a UDDI registry.
The service provider registers the service in a UDDI registry and/or ebXML registry/repository.
Another service or consumer locates and requests the registered service by querying UDDI and/or ebXML registries.
The requesting service or user writes an application to bind the registered service using SOAP in the case of UDDI and/or ebXML.
Data and messages are exchanged as XML over HTTP.

Web Service Infrastructure

Even though Web services are being built using existing infrastructure. The core architectural foundation of Web services are XML, XML namespaces, and XML schema. UDDI, SOAP, WSDL, ebXML and security standards are being developed in parallel by different vendors.

Web Services Technologies and Tools

There are a number of mechanisms for constructing Web services. Microsoft has an exciting tool called Visual Studio .NET in this regard. The back end database can be rational database.

Sun Microsystems has its own set of technologies and tools for facilitating Web services development. Java Servlets, Java Server Pages (JSPs), Enterprise JavaBeans (EJB) architecture and other Java 2 Enterprise Edition (J2EE) technologies play a very critical role in developing Web services.
There are a number of tools for developing Web services. They are Forte Java IDE, Oracle JDeveloper, and WebGain Studio.
Sun Microsystems has taken an initiative called Sun ONE (Open Network Environment) and is planning to push Java forward as a platform for Web services. It is developing Java APIs for XML-based remote procedure calls and for looking up services in XML registries - two more JAX family APIs: JAX/RPC (Java API for XML Remote Procedure Calls) and JAXR (Java API for XML Registries). These will wrap up implementations of Web services standards, such as SOAP and UDDI.

IBM also for its part has already developed a suite of early-access tools for Web services development. They are Web Services Toolkit (WSTK), WSDL Toolkit, and Web Services Development Environment (WSDE).

Benifits over Web Services

Exposing the function on to network - A Web service is a unit of managed code that can be remotely invoked using HTTP,Web Services allows you to expose the functionality of your existing code over the network. Once it is exposed on the network, other application can use the functionality of your program.

Connecting Different Applications - Web Services allows different applications to talk to each other and share data and services among themselves. Other applications can also use the services of the web services.

Standardized Protocol - Web Services uses standardized industry standard protocol for the communication. All the four layers (Service Transport, XML Messaging, Service Description and Service Discovery layers) uses the well defined protocol in the Web Services protocol stack.

Low Cost of communication - Web Services uses SOAP over HTTP protocol for the communication, so you can use your existing low cost internet for implementing Web Services. This solution is much less costly compared to proprietary solutions like EDI/B2B.

Support for Other communication means - Web Services can also be implemented using ftp protocol (Web services over FTP).

Loosely Coupled Applications -Different applications in different scopes communicate using Web services.

Web Services Sharing - These days due to complexness of the business, organizations are using different technologies like EAI, EDI, B2B, Portals etc. for distributing computing. Web Services supports all these technologies, thus helping the business to use existing investments in other technologies.

Web Services are Self Describing - Web Services are self describing applications, which reduces the software development time. This helps the other business partners to quickly develop application and start doing business. This helps business to save time and money by cutting development time.

Automatic Discovery - Web Services automatic discovery mechanism helps the business to easy find the Service Providers. This also helps your customer to find your services easily. With the help of Web Services your business can also increase revenue by exposing their own Web Services available to others.

Business Opportunity - Web Services has opened the door to new business opportunities by making it easy to connect with partners.

The Elements of Web Services

Web services use XML to code and to decode data, and SOAP to transport it (using open protocols). Besides these, HTTP, Web Services Description Language (WSDL), Universal Description, Discovery and Integration (UDDI), and SPARQL are the elements of Web Services.

Uses of Web Services

Web services are a set of tools that can be used in a number of ways most commonly in three styles:

Remote Procedure Calls
Service-oriented architecture
Representational state transfer

Moreover, it is also used as Reusable application-components and Connect existing software.

Exchange 2007 Web services

2011-03-25T07:04:00.000-07:00

Introduction

Recently, I had a chance to work on Exchange Web Services (EWS) API for 2007 version. Earlier, I had worked with Exchange 2003 and 2007 server for WebDAV protocol. As of my experience which I have had with Web Services and WebDAV API, Web Services is not an easy task since control is not in your hand. EWS provides a set of XML files through which you can prepare Java client for Exchange server communication. This Java client contains their own set of Java interfaces which needs to understand first for implementing your API. On other hand, WebDAV API controls easily by taking care of Exchange server properties.

About Exchange Server

Microsoft Exchange server is a server side of client-server model. This is a collaborative application product developed by Microsoft. Exchange's major features are mailing, calendaring, contacts and tasks. Exchange server supports for mobile and web based applications and it is treated as a database storage for collaborative items (Exchange server items).

About Exchange Web Services

Exchange Web Services is an interface which is used to communicate with Exchange server. This interface is exposed as SOAP (Simple object access protocol) based Web-service, which means requester must send his request in form of XML using SOAP to EWS contained in HTTP post request. EWS itself responds in the same manner using SOAP and XML messages in the HTTP response object. EWS is exposed on a Exchange Client Access Server (CAS) through an ASP.NET Web service. The basic flow of request/response is as follows,

For understanding the basics of Web services, please go through my one of post Web services basics.

Exchange 2007 Web-services

1) Exchange Web Services
2) Autodiscover Service
3) Unified Messaging Web Service

Exchange Web Services

Exchange Web Services provides the functionality to enable client applications to communicate with the Exchange server. Exchange Web Services provides access to much of the same data that is made available through Microsoft Office Outlook.

Exchange Web Services is described by three files:
1) Services.wsdl Describes the contract between client and server.
2) Messages.xsd Defines the request and response SOAP messages.
3) Types.xsd Defines the elements that are used in the SOAP messages.

These schema files are located in the EWS virtual directory of the computer that is running Exchange 2007 that has the Client Access server role installed.

Exchange Web Services provides the following types of operations:

1) Availability
2) Delegate Management (starting with Exchange 2007 Service Pack 1)
3) Folder
4) Item
5) Messaging Records Management
6) Notification
7) Synchronization
8) Utility

Autodiscover Service

The Autodiscover service provides a mechanism to automatically configure Exchange 2007 client applications to access the Client Access server. Autodiscover provides a powerful tool for configuring client application profiles used to discover Exchange Web Services and associated mailbox information. Autodiscover provides configuration information inside or outside of firewalls. In addition, Autodiscover will work in resource forest and multiple forest scenarios.

Unified Messaging Web Service

The Unified Messaging Web Service provides an extensibility point for clients to read and change information about Unified Messaging properties.

Why we use EWS?

As per me, I have worked with WebDAV supported API which supports till Exchange 2007 server. Beyond this versions, Exchange does not support for WebDAV. It supports only for EWS. This is my concern for using EWS.

There are some nice links for understanding EWS and its specifications in detail.

1) MSDN Getting Started With EWS : Introduction to Exchange 2007 Web Services.
2) EWS Operations : A list of the operations that can be performed on the EWS.
3) Glen Scales’ Blog : This guy knows Exchange inside and out.
4) EWS Basics : Basics of Exchange 2007 Web Services.
5) Programming With Exchange Server 2007 : Three part searies of EWS programming.
6) Rolf Woll's technical blog : Integrating Java with Exchange

Specifications implemented on EWS

1) HTTP
2) XML
3) Simple Object Access Protocol (SOAP)
4) Web Services Description Language (WSDL)

EWS Architechture

The following figure shows how a client application interacts with the Client Access server to access Exchange store information from the Mailbox server.

Applications that use Exchange Web Services can access data store items. The applications can access these items locally or remotely by using a SOAP version 1.1 or version 1.2 message. SOAP is an XML-based protocol that is defined in the World Wide Web Consortium (W3C). The SOAP messages are sent between client and server, embedded in an HTTP 1.1 message. The HTTP 1.1 protocol is defined by RFC 2616.

Exchange Web Services is deployed with the Client Access server role. Microsoft Exchange Server 2007 clients connect to the computer that is running Exchange 2007 that has the Client Access server role installed in an Active Directory directory service site by using an HTTPS connection.

EWS request and response flow

The following figure shows the steps involved in sending and receiving XML messages between the client application and the Exchange server.

When a client application requests information from the Exchange store, an XML request message that complies with the SOAP standard is created and sent to the Exchange server. When the Microsoft Exchange server receives the request, it verifies the credentials that are provided by the client and automatically parses the XML for the requested data. The server then builds a SOAP response that contains XML data that represents the requested strongly typed objects and their properties. The XML data is sent back to the client application in an HTTP response. The client application then de-serializes the XML and uses the data to reform the strongly typed objects.

Track version info for any Exchange server

2011-02-08T09:31:00.000-08:00

Introduction

This post will explain you, how to find Exchange server version information. Basically, we can not find Exchange server version information from server console however we can find this from Active directory shema (i.e. ms-Exch-Schema-Version-Pt).

There is a common attribute ('rangeUpper') for all active directories which helps us for retrieving Exchange server version info. This is very helpful for my project since my project connects with different Exchange servers and we pass Exchange server version information at the time of connection. If we do not know about Exchange server version info, we can not retrieve Exchange items.

Now, we get this at run time (Exchange server version info) when we make connection with Exchange server. We can connect with n number of Exchange servers using n number of Exchange users.

In this feature, you do not need to know about Exchange server. Only you need to know about Core Java and Active directory (Internally configured with Exchange server).

First, we take a look, how can we access this using Softerra LDAP Browser (software Version 2.6).

Exchange Server Version information using LDAP Browser

1) Open LDAP browser, create a new profile for Exchange’s Active directory.

2) Provide profile name here,

3)   Provide useful details for connection.
       Host : Exchange server host / fully qualified DNS name
       Port: LDAP port
       Base DN: ‘CN=ms-Exch-Schema-Version-Pt, cn=schema, cn=configuration, dc=<domain>, dc=<local>’
       For Example: Base DN = ‘CN=ms-Exch-Schema-Version-Pt, cn=schema, cn=configuration, dc=portmail, dc=com’

Click ‘Next’ to continue..

4) Provide useful information for directory user,
User DN: ‘CN=utest1, CN=Users, dc=<domain>, dc=<local>’
Password: <user password>
For Example: CN=utest1, CN=Users, DC=portmail, DC=com

Click ‘Next’ to continue..

5) Provide filter information here.

6) Provide password of directory user here.

7) Here, you can see the value of ‘rangeUpper’ attribute. This returns integer value which is unique for Exchange servers.

These are unique codes for each Exchange servers.

4397: "Exchange Server 2000 RTM"
4406: "Exchange Server 2000 Service Pack 3"
6870: "Exchange Server 2003 RTM"
6936: "Exchange Server 2003 Service Pack 3"
10628:"Exchange Server 2007 RTM"
11116:"Exchange Server 2007 Service Pack 1"
11222:"Exchange Server 2007 Service Pack 2"
14625:"Exchange Server 2007 Service Pack 3"
12640:"Exchange Server 2010 RTM"
13214:"Exchange Server 2010 Service Pack 1"

Now we will understand how can we achieve this via Java code.

Exchange Server Version information using Java Utility

1. First, you need to establish connection with LDAP server.

            Hashtable env = new Hashtable();
            env.put(Context.INITIAL_CONTEXT_FACTORY,"com.sun.jndi.ldap.LdapCtxFactory");
            env.put(Context.SECURITY_AUTHENTICATION, "Simple");
            env.put(Context.SECURITY_PRINCIPAL, userID);
            env.put(Context.SECURITY_CREDENTIALS, password);
            env.put(Context.PROVIDER_URL, ldapURL);
            ctx = new InitialLdapContext(env, null);

2. Once connection is done, you would need to search required attribute with filter information.

            SearchControls controls = new SearchControls();
            controls.setSearchScope(SearchControls.SUBTREE_SCOPE);
            String[] attributes = {"rangeUpper"};
            controls.setReturningAttributes(attributes);
            String filter = "";
            filter = "(&(objectClass=top)(objectClass=attributeSchema))";
            NamingEnumeration values = ctx.search(dirSearch, filter, controls);

3. Now you get attribute value from values enumerator.

JSR 286 Portlet filter feature

2010-10-05T08:47:00.000-07:00

JSR 286 introduces a new feature of portlet filter which is not included in earlier version of JSR specification. In this post, I am going to describe portlet filter feature briefly along with implementation code and example.

What is Portlet Filter?

Portlet filter is a piece of code that can transform content of portlet request and response. The concept is almost same as we already learnt from Servlet filter.
A filter by implementing one of the javax.portlet.filter.XYZFilter interfaces and providing a public constructor taking no arguments. A filter is declared using the <filter> element in the portlet deployment descriptor. A filter or collection of filters can be configured for invocation by defining <filter-mapping> elements in the portlet deployment descriptor.

Portlet Filter Lifecycle -

When request comes for portlet access, portlet container locate list of filters first and create instances of filters from the list and then calls init(FilterConfig config) method of filter.
When the container receives an incoming request, it takes the first filter instance in the list and calls its doFilter method, passing in the PortletRequest and PortletResponse, and a reference to the FilterChain object it will use.

Depending on target method of doFilter call, the PortletRequest and PortletResponse must be instances of the following interfaces:

1) ActionRequest and ActionResponse for processAction calls
2) EventRequest and EventResponse for processEvent calls
3) RenderRequest and RenderResponse for render calls
4) ResourceRequest and ResourceResponse for serveResource calls

Before a filter instance can be removed from service by the portlet container, the portlet container must first call the destroy method on the filter to enable the filter to release any resources and perform other cleanup operations.

Portlet Filter Configurations on application -

A filter is defined in the deployment descriptor using the <filter> element. In this element, the programmer declares the following:

1) filter-name: used to map the filter to a portlet
2) filter-class: used by the portlet container to identify the filter type
3) lifecycle: used to determine for which lifecycles the filter should be applied
4) init-params: initialization parameters for a filter

Here is an example of a filter declaration:

<filter>
<filter-name>MyPortletFilter</filter-name>
<filter-class>com.ibm.portletfiltersexample.MyPortletFilter</filter-class>
<lifecycle>RENDER_PHASE</lifecycle>
</filter>

Once a filter has been declared in the portlet deployment descriptor, the <filter-mapping> element is used to define portlets in the portlet application to which the filter is to be applied. Filters can be associated with a portlet using the <portlet-name> element.

PortletFiltersExample portlet:

<filter-mapping>
<filter-name>MyPortletFilter</filter-name>
<portlet-name>PortletFiltersExample</portlet-name>
</filter-mapping>

Filters can be associated with groups of portlets using the ‘*’ character as a wildcard.

<portlet-name>*</portlet-name>

A portlet filter can be applied to different lifecycle method calls: processAction, processEvent, render, serveResource. The following constants are valid values for the <lifecycle> element:

1) ACTION_PHASE requesting that the portlet container processes this filter for the processAction lifecycle method. The filter implementation must implement the ActionFilter interface.
2) EVENT_PHASE requesting that the portlet container processes this filter for the processEvent lifecycle method. The filter implementation must implement the EventFilter interface.
3) RENDER_PHASE requesting that the portlet container processes this filter for the render lifecycle method. The filter implementation must implement the RenderFilter interface.
4) RESOURCE_PHASE requesting that the portlet container processes this filter for the serveResource lifecycle method. The filter implementation must implement the ResourceFilter interface.

Example:

<filter>
<filter-name>MyPortletFilter</filter-name>
<filter-class>com.ibm.portletfiltersexample.MyPortletFilter</filter-class>
<lifecycle>ACTION_PHASE</lifecycle>
<lifecycle>RENDER_PHASE</lifecycle>
</filter>

In this example the portlet filter is applied to the action and render phase.

And the code of filter class, which implements RenderFilter interface, is as:

public class MyPortletFilter implements RenderFilter {

public void init(javax.portlet.filter.FilterConfig arg0) throws PortletException {
// TODO Auto-generated method stub
}

public void doFilter(RenderRequest req, RenderResponse res, FilterChain chain) throws IOException,PortletException {
System.out.println(" DEBUG: M Portlet Filter Pre-processing a render request");
// Hand off control to the next filter in the chain, or the portlet itself if no more filters

   chain.doFilter(req, res);
   System.out.println(" DEBUG: M Portlet Filter Post-processing a render request");
}

public void destroy()
{
   System.out.println("DEBUG: Destroying My Portlet :-(");
}
}

If you need any sample application of portlet filter, you please click on followning link and download the attached applicaton 'PortletFiltersExample.war' in dilip's post.

http://www.ibm.com/developerworks/forums/thread.jspa?threadID=316941&tstart=0

Serving resource using JSR 286

2010-08-23T03:14:00.000-07:00

In JSR 286, one more method is getting introduced in portlet life cycle that is serveResource, the advantage of this method is, we can get resource in portlet response which is not possible in JSR 168.

Let's take an example for better understanding the use of serveResource method. Suppose, you have a collection of images and you need to display different images according to the selection. What you will do is?
First, you need to create a resource URL as mentioned below,

ResourceURL resourceURL = renderResponse.createResourceURL();

Now, you need to make a hiperlink through which you call the serveResource method. The code for reference is,

<a href="<%=resourceURL.toString() %>">Resource</a>

When you click on this link, it makes an Ajax call using resourceURL and call the serveResource method. Once it is called you can set the response for images (which is not effected in JSR 168) and write this byte format of image in XML format. Now response is ready which is called using Ajax callback methods. The reference code lines are,

public void serveResource(ResourceRequest request, ResourceResponse response) throws PortletException, IOException {
response.setContentType("image/jpeg");
// Image in byte stream
byte[] b = getImage(); //Returns image bytes
// writing image byte stream on portlet response
response.getPortletOutputStream().write(b);
}

Also, you can use different types of resources. What you need to do is?
you have to add the following code with resourceURL,
resourceURL.setResourceID("image");

Through this ID you can perform your logic according to the image resource ID. You can get Id in serveResource method using code below,

request.getResourceID().

JSF Page navigation using RAD 7 Add Rule feature

2010-08-22T06:10:00.000-07:00

JSF provides page navigation using navigation-rule of faces-config.xml file. In this rule, you need to mention source JSP, destination JSP file and a token which returns from managed-bean method.
I will do the same thing using ‘Add Rule’ feature of RAD 7. Let’s see how we can do it?

First you need to open the JSP page in design view and single click on ‘SAVE’ button. Thereafter, you need to select ‘Properties’ tab (Lower middle portion of RAD) and then select ‘hx:commandExButton’ option. There you can see Add Rule button.

Please click on ‘Add Rule’ button (Right upper portion of properties tab). You will get ‘Add Navigational Rule’ window. Here you will mention final JSP page, the outcome name and action if required. Press OK button once you fill all the required information.

You can see the added code in faces-config.xml file as,

<navigation-rule>
<from-view-id>/UserInformationView.jsp</from-view-id>
<navigation-case>
<from-outcome>success</from-outcome>
<to-view-id>/UserInfoDetails.jsp</to-view-id>
</navigation-case>
</navigation-rule>

JSF page design using drag and drop feature

2010-08-22T04:32:00.000-07:00

JSF is a standard specification for building user interfaces. In this specification, drag and drop feature is also useful. In this feature, you can use existing beans for designing the web page. Through drag and drop feature, we can design our page very fast. For designing, we will use ‘page data’ option of RAD which will available in ‘web’ perspective.

First, you need to create a bean in which you can use two fields username and address. Codes for bean are,

public class UserInfo {
    private String userName;
    private String address;
    public String getAddress() { return address;     }
    public void setAddress(String address) { this.address = address; }
    public String getUserName() { return userName; }
    public void setUserName(String userName) { this.userName = userName;     }
}

Now, you will need to use Page Data (lower left portion of the RAD) option of RAD in ‘web’ perspective. You would need to create a new ‘Page Bean’ using existing bean named ‘UserInfo’. You can create new ‘Page Bean’ once you right click on ‘Page Bean’ option and come into New>Java Bean option and click on ‘Java Bean’ option. You can see the picture below,

You can see ‘Add JavaBean’ window where you can provide a new name (name starts with first lower case character) and add existing java-bean class. Also, if you want to make this bean class as managed bean, you can check the checkbox and select the scope of bean and press finish button.

Now, you need to drag the ‘userInfo’ Page Bean and drop it into cursor location of JSP page.

You will see ‘Insert JavaBean’ wizard in picture below. Here you will see java bean entries as input field of JSP page.

You can add submit button also using ‘options’ button. When you click on options button, you will get following window. Provide label name and press OK button.

You can see additional JSP code in picture below,

The preview of JSP page as,

In this way, we can implement drag and drop feature using java-bean classes. Apart from this, JSF provides lots of components in palette which you can drag and drop it in JSP file for designing your page vary efficiently. For each page, JSF automatically creates java-code which you can find in pagecode package.

JSF portlet application directory structure and required JAR files

2010-08-22T04:12:00.000-07:00

You can see directory structure of basic JSF portlet application in picture below,

In this diagram, you can see ‘src’ folder which contains all the source code and WebContent folder which contains the web pages and WEB-INF directory. In WEB-INF directory, we do have three required files these are,

1) faces-config.xml file
2) portlet.xml file
3) web.xml file

and we do have four required JAR files. These are,

1) icu4j_3_4_1.jar
2) jsf-ibm.jar
3) jsf-impl-messages.jar
4) jsf-portletbridge.jar

JSF portlet development using RAD 7.0

2010-08-22T04:07:00.000-07:00

IBM RAD 7.0 provides integrated feature for developing JSF based portlets.

Through RAD, you can develop basic JSF portlet.

Let’s see, how can we develop JSF portlet using RAD 7.0? First you need to open the RAD 7.0 and come into File>New>Project option. You can see the picture below.

While creating new project, please select portlet project option and press Next button.

You will get ‘New Portlet Project’ wizard where you need to mention project name, portal server version, portlet API and portlet type. Press Next once you fill all the required information.

Now you need to add portlet modes and press finish button and you will get a basic JSF portlet application with required JAR file and configuration files.

How portlet modes work in portal environment?

2010-07-07T05:31:00.000-07:00

I have one JSR-168 based portlet in which I am using all kinds of modes. These are,

1) View Mode
2) Edit Mode
3) Help Mode
4) Edit-Default Mode
5) Config Mode

Now, I have one question in my mind. What is the use of these modes? If we take an example of any web-based application which is deployed on web container and this application does not have any kind of mode. Here I am going to describe a brief description of portlet modes which are helpful to understand the benefits of portlet application over web-based J2EE application.

View Mode -

This is the landing page of the portlet.

Edit Mode -

This is the different page of the portlet for storing personalized settings. These settings allowed for a particular instance of the portlet for particular portal user. If we make another instance of portlet in another page, personalized variable is not allowed to accessible.

Edit - Default Mode -

This is also different page of the portlet. We are using this mode for storing the configuration parameters of the portlet which are accessible for all portal users for the same portlet instances. For Example. An admin stores some parameters in edit-default mode of portlet and check the availability of these parameters in other portal users. These parameters are available for all portal users for a particular instance of the portlet suppose you add same portlet in different page, you will not allowed to see stored parameters for different instances of portlet.

Config Mode -

This is also different page of the portlet. We are using this mode for storing the configuration parameters of portlets which is accessible for all portal users for all portlet instances.

Now we have a big picture, how these modes are working in portal environment? We have tested this procedure for IBM Web Sphere portal server 6.0 using RAD 7.0 and JSR 168 specification.

JSF portlet example using datatable

2010-06-29T23:45:00.000-07:00

This is also a good feature of JSF in which we are using datatable tag of JSF html tab library. You can find this tag on Palette portion. For implementing into webpage, you just need to drag this from palette and drop this in cursor position of webpage.

You will get the default code in webpage and there is no need to provide loop for table items. This tag manages all the list items according to the prototype provided by us.
Only one thing you need to keep in mind the value field in datatable tag which makes a call for perInfoAll method from syncExLoginManagedBean and the var field is the name of the table through which we can fetch the table items.
In datatable tag, facet tag provides the header of table and outputText provides the text value in data table.

<hx:dataTableEx border="0" cellpadding="2" cellspacing="0"
columnClasses="columnClass1" headerClass="headerClass"
footerClass="footerClass" rowClasses="rowClass1, rowClass2"
id="tableEx1" styleClass="dataTableEx" value="#{syncExLoginManagedBean.perInfoAll}" var="item">

<f:facet name="header">
<h:outputText value="This is 'SyncEx data Table' demo" />
</f:facet>

<hx:columnEx id="columnEx1">
<f:facet name="header">
<h:outputText id="text1" styleClass="outputText" value="ID"></h:outputText>
</f:facet>
<h:outputText value="#{item.id}"></h:outputText>
</hx:columnEx>

<hx:columnEx id="columnEx2">
<f:facet name="header">
<h:outputText id="text2" styleClass="outputText" value="Name"></h:outputText>
</f:facet>
<h:outputText value="#{item.name}"></h:outputText>
</hx:columnEx>

<hx:columnEx id="columnEx3">
<f:facet name="header">
<h:outputText id="text3" styleClass="outputText" value="Phone"></h:outputText>
</f:facet>
<h:outputText value="#{item.phone}"></h:outputText>
</hx:columnEx>

<hx:columnEx id="columnEx4">
<f:facet name="header">
<h:outputText id="text4" styleClass="outputText" value="City"></h:outputText>
</f:facet>
<h:outputText value="#{item.city}"></h:outputText>
</hx:columnEx>

<f:facet name="footer">
<h:outputText value="The End" />
</f:facet>
</hx:dataTableEx>

JSF page script code using RAD quick edit feature

2010-06-29T23:39:00.000-07:00

First you need to open the JSP page in design view and single click on ‘SAVE’ button. Thereafter, you need to select ‘Quick Edit’ tab (Lower middle portion of RAD) and then select required function which will execute when you click on SAVE button. Suppose you want to implement onclick function once you click on SAVE button so you need to select onclick once and then click on right portion where you can add the required code for onclick java script function.

You can see the added code in JSP file

<script type="text/javascript">
function func_1(thisObj, thisEvent) {
//use 'thisObj' to refer directly to this component instead of keyword 'this'
//use 'thisEvent' to refer to the event generated instead of keyword 'event'
alert("hello");
}</script>

<hx:commandExButton id="button1" styleClass="commandExButton" type="submit" value="SAVE" action="#{pc_UserInformationView.doButton1Action}" onclick="return #{facesContext.externalContext.response.namespace}func_1(this, event);">
</hx:commandExButton>

JSF tags reference

2010-06-20T07:02:00.000-07:00

While developing JSF pages, we require a good understanding of JSF tags libraries. Mainly JSF provides two kind of tags library one is for core and second is for HTML.
Let's try to understand, how these two tags library has been used in JSF pages? You have to add the following lines in JSF pages,

JSF tag libraries-core
%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

JSF tag libraries-HTML
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>

For understanding the core tags library in detail, you can go through the following link ,http://myfaces.apache.org/core20/myfaces-impl/tlddoc/f/tld-summary.html

For understanding the HTML tags library in detail, you can go through the following link
http://myfaces.apache.org/core20/myfaces-impl/tlddoc/h/tld-summary.html

In my searching I found some others links which are good to understand the basics of tags library. These are,

http://www.exadel.com/tutorial/jsf/jsftags-guide.html
http://www.roseindia.net/jsf/JSF_Core_Tag_Reference.shtml

JSF inter portlet communication

2010-06-19T06:00:00.000-07:00

Let me start with Inter portlet communication feature of portlets. Firstly, I will give you a brief idea about Inter portlet communication. This is not a new terminology. As web-developers who are using servlets, JSPs and portlets for development purpose. If they want to pass some parameters from one resource to another resource what they will do? In servlets, they can use RequestDispatcher to achieve this functionality and for portlets itself, they can use Inter portlet communication feature.

In portlets, Inter portlet communication can implement by following ways.

1) Using portlet session in Application scope.
2) Using IBM's property broker services (portlet wiring).
3) Eventing using JSR -286 specifications.
4) Public render parameter using JSR-286 specification.

In this post, I will describe Inter portlet communication using portlet session (first point) and JSF eventing feature. You can see detail description of JSF portlet framework flow in one of our posts.
I am taking an example of two portlets. First portlet is calculator portlet which contains two numbers and four submit buttons (for ADD, SUBTRACT, MULTIPLY and DIVIDE operations) and second portlet shows the result according to the operation performed by first portlet. You can see the whole picture of Inter portlet communication in the picture below,

Now, you need to add portlet configuration for both portlets in portlet.xml file. You need to add init parameters which tell the JSF portlet about the render file (JSP file).

For SyncExCalculator portlet:
<init-param>
<name>com.ibm.faces.portlet.page.view</name>
<value>/SyncExCalculatorView.jsp</value>
</init-param>

For SyncExCalculatorResult portlet:
<init-param>
<name>com.ibm.faces.portlet.page.view</name>
<value>/SyncExCalculatorResultView.jsp</value>
</init-param>

Now, both portlets are rendered successfully and call both JSPs which look as given picture below.

We need to understand how the action is being created from SyncExCalculatorView.jsp (first portlet).

<h:commandButton id="addsubmit" action="#{CalculatorController.add}" type="submit" value="ADD" />

Here, you can see the action which is for add() method of CalculatorController bean. Now we need to understand how JSF gets executed add method. When I click on ADD button of portlet, JSF portlet looks up the entry of the managed bean (CalculatorController) in faces-config.xml file.

<managed-bean>
<managed-bean-name>CalculatorController</managed-bean-name>
<managed-bean-class>com.yash.beans.CalculatorController</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
</managed-bean>
Here, scope of bean is session which contains the bean in session scope.

In this way, JSF looks up the bean and calls add method of bean. In add method of bean we provide all business logics (perform logic for adding two numbers) and store the results in FacesContext using ApplicationMap. I am storing the result value in ApplicationMap since I need to use result value in other portlet. The code lines are,

FacesContext context = FacesContext.getCurrentInstance();
context.getExternalContext().getApplicationMap().put("result", new Integer(result));

The result has been saved in FacesContext. Now I have to retrieve the same result value in other portlet so what will I do? I will make another method which retrieves the result value from FacesContext. The code lines are,

FacesContext context = FacesContext.getCurrentInstance();
Map requestParams = context.getExternalContext().getApplicationMap();
result1 = ((Integer)requestParams.get("result")).intValue();

You can get the result value in JSP (SyncExCalculatorResultView.jsp) of another portlet as,

<h:outputText value="#{CalculatorController.result1}" />

This code of line does the same thing. This line makes a call for result1 method of CalculatorController bean and uses the same entry of managed bean which I have used earlier for first portlet.

This is the way, We can implement Inter portlet communication feature using Java Server Faces Specification. You can mail us on my mail id for source code.

Understanding Java Server Faces Portlet Workflow

2010-06-18T12:45:00.000-07:00

For understanding the JSF portlet workflow, Let's start with portlet life cycle in which we are using two important methods. These are,
1) doView()
2) processAction()

When portlet renders first time, it calls doView() method of portlet life cycle. When we create any action (Click on link, submit button) processAction() method gets called, followed by doView() method. In doView() method, we usually include JSP which represents portlet's view. We perform these (portlet mode) operations on portlet class which includes in <portlet-class> tag under portlet.xml file. This class is modifiable.

In the same way, Java Server Faces specification also looks the portlet entry in <portlet-class> tag under portlet.xml file.

<portlet-class>com.ibm.faces.portlet.FacesPortlet</portlet-class>

Here, FacesPortlet is not allowed to modify the code. It contains all modes as I described in portlet life cycle and it understands all actions and JSP page includes in its own way. Here, I will describe you how JSF will do this.Firstly, I will let you know how JSF includes JSP on rendering phase of portlet. You have to include following lines in portlet.xml file.

<init-param>
<name>com.ibm.faces.portlet.page.view</name>
<value>/CalculatorPortletView.jsp</value>
</init-param>

JSF portlet class is much smarter which understands JSP file and includes in to render phase. We do not need to create an instance of RequestDispatcher and include the JSP file as we do in portlet life cycle.

Now, we need to understand, how action is handled by JSF? since we can not modify FacesPortlet class as we can do in portlet life cycle. This is also a very tricky approach which is done by JSF. When we click on any button or link in JSP page, JSF internally makes a call of processAction() method of portlet which finds managed bean class in faces-config.xml file and creates an instance of bean in different scope (request, session). You can understand this by following example,

Here, we are creating one action which executes when we click on submit button. It creates an action add which will get in CalculatorController managed bean .

<h:commandButton id="submit" action="#{CalculatorController.add}" value="ADD" />

The managed bean entry is present in faces-config.xml which creates a instance of CalculatorController bean and calls add() (event action called from JSP page) method in it.

<managed-bean>
<managed-bean-name>CalculatorController</managed-bean-name>
<managed-bean-class>com.yash.CalculatorController</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
</managed-bean>

Now action created from JSP file executes completely. Thereafter, it looks up the navigation rule which provides the way for redirecting control to another JSP file or the same file. The codes for navigation rule are,

<navigation-rule>
<from-view-id>/CalculatorPortletView.jsp</from-view-id>
<navigation-case>
<from-outcome>success</from-outcome>
<to-view-id>/result.jsp</to-view-id>
</navigation-case>
<navigation-case>
<from-outcome>failure</from-outcome>
<to-view-id>/CalculatorPortletView.jsp</to-view-id>
</navigation-case>
</navigation-rule>

This code represents source JSP file CalculatorPortletView.jsp (form-view-id) from where the action creates and according to the return statement of add method, it forwards the request to another JSP file.

Java Server Faces Page Lifecycle

2010-06-18T04:05:00.000-07:00

This section discusses the various phases involved in a typical JSF page life cycle. JSF life cycle is expressed in the following phases:

Reconstruct Component Tree

This phase is initiated when a page request is submitted to the server (i.e a user clicks a submit button on a web page). During this phase the server creates a hierarchical tree of UI components which represent the elements constituting the page. The JSF engine parses this component tree and wires all the declared event handlers and validators to the specific components. All this information is finally persisted in a FacesContext. A faces context is nothing but a snapshot, an object tree representation of the incoming page. This information is utilized in the following phases until the response is rendered.

Apply Request Values

In this phase the JSF engine applies the values from the request object (parameters) to the respective components in the component tree (available from the current FacesContext) created in the previous phase. These values are stored locally in the UI components. In the event that conversion errors occur during storage of these values, they are queued up in the FacesContext, so they can be displayed when the content is finally rendered. If any event handlers were associated with specific components, they are notified of the relevant events.

Perform Validations

After the request values have been applied, the JSF page enters the validation phase, wherein all the registered validators are applied to relevant UI components. The locally stored values of these components are run through the associated validators and validation errors, if any, are queued in the FacesContext. If validation errors occur in this phase, the JSF engine skips the next two phases and the page enters the Render Response phase. The page is reconstructed from the component tree and displayed along with the validation errors and any errors or messages queued up in the FacesContext from the Apply Request Values phase. If no validation errors are detected, the page enters the Synchronize Model phase and any events generated at this point are broadcast to the interested event handlers.

Synchronize Model

In this phase any model objects associated with UI components are synchronized to the UI component's local value. If any conversion error occurs at this point, (e.g. a String value is mapped to an Integer property in a model object and cannot be parsed into an integer), the errors are queued in the FacesContext and the page enters the Render Response. The page is recreated from the component tree and rendered to the user displaying the conversion errors which occurred in this phase. Also any events generated at this point are broadcast to the interested event handlers.

Invoke Application Logic

After the model has been successfully synchronized, the page enters this phase. In this phase the JSF engine handles all application level events, such as linking to another page, performing updates to back end services, database updates, etc. When processing an application level event, a default ActionListener determines the outcome of the Action and passes the outcome to the NavigationHandler. The NavigationHandler then looks up the response to be generated from the navigation rule defined in the application configuration file, based on the outcome of the application logic, i.e. success or failure. The component tree for the next page to be generated is constructed and the page enters the final stage.

Render Response

In this phase the JSF engine renders the UI components in the component tree persisted in the FacesContext. If any errors or messages have been queued up from previous phases, they are rendered along with the page. This component tree is persisted so subsequent requests to this page can access it and it is readily available to the Reconstruct Component Tree phase.

Reference taken by: http://jnb.ociweb.com/jnb/jnbAug2003.html

Quick Understanding of Java Server Faces (JSF)

2010-06-17T11:26:00.000-07:00

I would like to share my experience when I started work on JSF specification. I have development experience on portlets using JSR-168 and I tried to search technical notes which helps me to understand the JSF specification for portlet development. In my searching, I am not able to get any helpful technical note. Here, I am trying to describe all the things which I have learn t for JSF portlet development.

In this post, I will cover the basics of JSF and in other posts I will cover other features of JSF with examples.

Why we use JSF?

Before introducing Java Server Faces, developers who built web applications often relied on building HTML user interface components with portlets or servlets or Java Server Pages (JSP pages). This is mainly because HTML user interface components are the lowest common denominator that web browsers support. The implication, of course, is that such web applications do not have rich user interfaces, compared with standalone fat clients, and therefore less functionality and/or poor usability.

For years ago, Microsoft has evangelized the benefits of drag-and-drop support when advertising their Visual Basic product which provides quick and easy to build applications. JSF provides the same kind of development approach in multi-threaded environment.

What is JSF?

Java Server Faces (JSF) is a very powerful, component-based technology that is being led by Sun Microsystems as JSR 127 under the Java Community Process (JCP). JSF is a user interface (UI) framework for web-applications. JSF lets you build web applications that run on a Java server and render the user interface back to the client. This technology provides web application life cycle management through a controller, and a rich component model with event handling and component rendering. JSF provides standard specification for building User Interfaces for server side applications.

Java Server Faces technology is based on the Model View Controller (MVC) architecture for separating logic from presentation, so if you have been practicing this, you'll feel at home with JSF.

What are the benefits of JSF?

1) Benefits over Software vendors
Several software vendors have updated their toolkits to support JSF, promising rapid development and ease of use through drag-and-drop support when creating JSF-based web applications.

2) Benefits over rich user interface tools
There are a number of options out there today for building rich server-side user interfaces, such as Flash, Swinglets, and Jade. However, these solutions are proprietary; the tools and runtimes that support their development are usually only available through a single vendor. JSF is, above all, a standard, which means that the developer does not get locked into a single vendor.

3) Benefits over different components
Component Vendors provide reusable building blocks for application development and integration into JSF-based tools. Components cover a wide range of uses including reporting, charts and graphs, fields, and navigational components. Here are some of the vendors who offer components that support the Java Server Faces specification.

1) Otrix WebMenu
2) ILOG JViews
3) Quest Software JClass
4) Software FX Chart FX

4) Benefits at User level
Several types of users can benefit from this technology, including:
1) Page authors who use markup languages, such as HTML, will use the JSP tag library for expressing JavaServer Faces rich user interface components.
2) Application developers who write the model objects and event handlers.
3) Component developers who will create custom components based on the JSF components.
4) Tools vendors who will provide tools that incorporate JSF technology into a new generation of tools that simplify the development of multi tier web-based applications.
5) Application Server vendors who provide a runtime environment that incorporates JSF technology into a new generation of Application Servers that can deploy multi tier web-based applications that use JSF technology.

5) Integrated Ajax support
You can use jQuery, Dojo, or Ext-JS with servlets and JSP. However, JSF lets you use Ajax without explicit JavaScript programming and with very simple tags. Also, the Ajax calls know about the server-side business logic.

6) Form field conversion and validation
JSF has builtin capabilities for checking that form values are in the required format and for converting from strings to various other data types. If values are missing or in an improper format, the form can be automatically redisplayed with error messages and with the previously entered values maintained.

7) Centralized file-based configuration
Rather then hard-coding information into Java programs, many JSF values are represented in XML or property files. This loose coupling means that many changes can be made without modifying or recompiling Java code, and that wholesale changes can be made by editing a single file. This approach also lets Java and Web developers focus on their specific tasks without needing to know about the overall system layout.

This technology also opens up the market for reusable web user interface components. Developers and vendors can use JSF as the building blocks for developing custom faces.

Disadvantages of JSF

1) Bigger learning curve
To use MVC with the standard RequestDispatcher, you need to be comfortable with the standard JSP and servlet APIs. To use MVC with JSF, you have to be comfortable with the servlet API and a large and elaborate framework that is almost equal in size to the core system.

2) Similarly, if you have an existing app and want to add in some small amounts of Ajax functionality, it is moderately easy with jQuery (quite easy if you know JavaScript already). Switching your app to JSF 2.0 is a big investment.

3) Less transparent
With JSF applications, there is a lot more going on behind the scenes than with normal Java-based Web applications. As a result, JSF applications are:
1) Harder to understand
2) Harder to benchmark and optimize

4) Undeveloped tool support
There are many IDEs with strong support for standard servlet and JSP technology. JSF 2.0 is pretty new, and IDE support is weak as of 5/2010.

5) Much weaker automatic validation
Struts comes with validators for email address, credit card numbers, regular expressions, and more. JSF only comes with validators for missing values, length of input, and numbers in a given range.
You can use the Struts/Commons validation library with JSF, but still not as powerful as Struts.

6) Lack of client-side validation
Struts supports JavaScript-based form-field validation; JSF does not.