Mathew's Thoughts

Virtual Appliances

2010-01-27T02:17:00Z

Recently I had to review a product which was being offered as a Virtual Appliance. This was the first time I had come across something like this. Pretty soon I was "googling" around to understand this better.

A virtual appliance is a pre-built, pre-configured virtual machine that has an OS, the application and other supporting software all packaged together and ready to go. All you do is to use a product such as VMWare Fusion/Player or Sun VirtualBox to play the appliance and viola you have a running product. I downloaded a Wordpress Virtual Appliance from http://www.turnkeylinux.org/wordpress. Turnkey has many other appliances at http://www.turnkeylinux.org/

I have both VMWare Fusion and Sun VirtualBox on my Mac. Next I either open the appliance in VMWare or Import the appliance in VirtualBox. In a few minutes I had the VM ready and the Wordpress application working like a champ. In my excitement to play with this toy i installed appliances for bugzilla and drupal. The simplicity of this is what amazed me.

I find this approach of delivering software very innovative. It drastically simplifies the administrative tasks required to setup an application. I do not know how efficient this modal is in real work use, but frankly I don't care its just too elegant.

Too learn more about Virtual Appliances check http://www.vmware.com/appliances/getting-started/learn/overview.html

JEE - The Road Ahead with JEE 6

2010-01-03T15:38:00Z

Prior to JEE 5 , the JEE/J2EE platform did not go down that well across the developer community. As software evolves and new ideas flow in, it was only natural that JEE 6 would refine and become a better platform.

Spring Framework came into being partly due to the complexity ofJ2EE. But today SF itself is getting large. SF gave you an abstraction on existing frameworks and made it easier to wire different technologies together. But as the complexities in JEE are addressed you have to start thinking if SF is an overkill. OK I did not exactly mean to say that but you need to think about it.

Below are a few notable items from JEE 6 (I do not go into the merits of each nor do I list every new feature):

Context & Dependency Injection (CDI). This allows for any POJO to be injected into dependent classes. Right now you have the ability to inject container managed resources (such as connection pools, EJB's). You cannot inject regular POJO objects. JEE6 adds that ability.
CDI - Introduces annotations such as
- @ManagedBean - Identifies a bean as a container managed bean.
- @Model identifies a model object in a MVC architecture.
- @*Scope annotations such as @SessionScoped which tie an instance of a bean to a scope such as request, session or application.
- @Inject is used to inject managed beans into other dependent classes.
- ...and so on...
CDI allows session beans to be used in place of JSF beans (influenced from Seam obviously). This means you can use session beans in your JSF EL expressions.
Bean Validations: Set of annotations to apply on java objects so that the validations can be shared between UI and backend tier.
Eliminate web.xml with new annotations such as @WebServlet, @WebFilter , etc.
Ability of servlets to respond to asynchronous requests (AJAX). This could greatly simplify the existing mechanisms on the server to handle such requests. Having the servlets take over this allows for more efficient use of server threads vs existing implementations.
Introducing the concept of web fragments. Basically separate web.xml files so that appropriate frameworks can be configured in their own files.
JSF 2.0 (includes annotations that let you eliminate the faces-config.xml file, AJAX support, facelets).
Simplication of EJB in 3.1 (no requirement for business interfaces, singleton beans, asyhnchronous session beans)
Concept of Profiles to differentiate between different configurations or stacks of JEE...similar to J2ME .See my article on J2ME at
http://my.advisor.com/doc/12697
Ability to package EJBs as part of the WAR file.
Inclusion of JAX-RS into the JEE spec (REST with JAX-RS).
Support for JPA 2.0 (notably to me is the inclusion of a Criteria API...such as the one in Hibernate).

While a lot of things have been added into JEE 6, I do not see any NEW path-breaking changes (except for the asynch servlet invocation). Seems to me JEE is playing catch-up with innovations in other OS frameworks (such a Spring,hibernate,etc).

In conclusion - I wonder where the next set of innovations will come from and what form they will take. I like that Spring has introduced "Spring Integration". This should allow applications to efficiently handle common integration patterns.

Is Axis2 way too complicated for web apps?

2009-12-11T03:24:00Z

I recently had the pleasure of using Axis2 on a Web Application. For reasons I cannot go into here, we were unable to use my original choice SpringWS. We were using Spring so it would have been a piece of cake to expose a document style web service using SpringWS.

When I finally got my application modified to use Axis2 to expose the web service, the final result was not pretty. In Axis2 you have to create the following in your WEB-INF

WEB-INF
   - services\
             services.list (list of aar file names ... one on each line)
             service1.aar
             service2.aar
- modules\
             modules.list (list of aar file names ... one on each line)
             module1.aar
- conf\
             axis2. xml

Each aar file contains in my case
service1.aar
        - META-INF\
              service.xml (this actually contains the service configuration for service1)

service.aar is a jar that contains your service configuration and any libraries that you may choose to include. In my case all libraries were in web--inf/lib. If you need to implement custom handlers (as was my case) you have to create modules and the corresponding module.aar file. If you want your handler to take effect you need to then pull out the axis2.xml file from the axis jar file, modify it to include your handler then put it into web-inf/conf

All this to even expose a simple secure hello world. I always wondered why Spring documentation did not cover integrating Spring with Axis2. Now I know. This is way too complicated ! Those who read this and say deploy as .jws , that wont work for me. Maybe it does for you.

Apache CXF - Simple WebService With Spring

2009-10-08T03:02:00Z

A reader posted a comment to one of my old blogs on XFire. That rekindled my interest so I checked the XFire web site only to be informed that XFire is now Apache CXF (version 2.2.3 at this moment in time).

So how hard would it be to convert my old example to CXF. Turned out to be a piece of cake. Had to change the following:

Updated the maven dependencies to reflect CXF libraries.
web.xml - to point to the CXF Servlet
Spring context (app-context.xml) - It was now a lot simpler and cleaner.
Finally I used CXF wsdl2java utils to generate a client

Maven pom.xml

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.aver</groupId>
    <artifactId>echo</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>CXF Echo Service</name>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring</artifactId>
            <version>2.5.6</version>
        </dependency>

        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxws</artifactId>
            <version>2.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http</artifactId>
            <version>2.2.3</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.7</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.14</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>maven-jetty-plugin</artifactId>
                <configuration>
                    <contextPath>/echoservice</contextPath>
                    <connectors>
                        <connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
                            <port>9090</port>
                            <maxIdleTime>60000</maxIdleTime>
                        </connector>
                    </connectors>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

The web.xml...

<web-app>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/app-context.xml
        </param-value>
    </context-param>

    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>

    <servlet>
        <servlet-name>CXFServlet</servlet-name>
        <servlet-class>
            org.apache.cxf.transport.servlet.CXFServlet
        </servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>CXFServlet</servlet-name>
        <url-pattern>/services/*</url-pattern>
    </servlet-mapping>
</web-app>

The Spring context file - app-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"
    xsi:schemaLocation="http://www.springframework.org/schema/beans www.springframework.org/schema/beans/spring-beans-2.0.xsd
    cxf.apache.org/jaxws 

">cxf.apache.org/schemas/jaxws.xsd">

    <import resource="classpath:META-INF/cxf/cxf.xml" />
    <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
    <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />

    <jaxws:endpoint id="echoService" implementor="#echo"
        address="/EchoService" />

    <bean id="echo" class="com.aver.EchoServiceImpl" />
</beans

The wsdl2java command I executed was:

./wsdl2java -p com.aver.client -client localhost:9090/echoservice/services/EchoService?wsdl

Run the project using maven: mvn clean package jetty:run
The WSDL is located at the address mentioned above in the wsld2java command.

Finally I ran the test client that wsdl2java generated...class named EchoService_EchoServicePort_Client

The output was:

Invoking echo...
echo.result=echo: 'uyy ' received on 10-07-2009 10:53:59 PM

Click here to download the maven project for this blog.

Spring Batch 2.0

2009-09-25T01:12:51Z

Previously I had written a 3 part series on Spring Batch 1.x. Since then Spring 2.x has been released and I promised myself (and one reader) that I would get to updating my previous articles to reflect the new release.

Rather than create new articles I have updated the previous 3 articles with the changes made in 2.x.

Happy reading!

Comet , HTML 5 Web Sockets and Server Sent Events (SSE)

2009-08-22T01:00:00Z

There has always been a need to support UI's that constantly update themselves as new data becomes available on the server. THe implementation for this falls into two general categories: either client side polling or server side push.

Comet is the term that is often used to describe current Client side polling and server side push techniques. Lets delve briefly into what the techniques are and then move to HTML 5 Server Sent Events and WebSockets. Check out Cometd for an implementation that you can try out. Cometd implements the Bayeux spec. Implementations are available in multiple languages.

Comet Techniques

Client Side Polling
Client periodically polls the server for new data and updates the UI as the data becomes available. The benefit of this is in its sheer simplicity. Downside is that for medium to high volume sites we introduce too many useless round trips to the server. From an architectural point of view if your volumes are relatively low this may be the right solution for you.

Client Side Polling - Long Polling
Slight variation from the previous ones. The client makes a call to the server for data. The server can hold onto the connection for some period of time. When data becomes available it is sent back and the connection is closed. If no data is available for a predefined time then the connection can be closed too. Once the connection is closed a new one is created and the process continues on. The obvious advantage of this is that we do not keep opening and closing too many connections from the client side.

Server Side Push
The idea here is for the server to push data updates to the client rather than the client polling the server for updates. In this data exchange pattern the client opens a connection to the server for which the server responds but the client does not close the connection. The client is in a continuous read mode on the connection. Whenever the server has data it sends it back within JavaScript <script> tags. Due to the way the browser renders incoming data, any JavaScript is executed which is how we can call our callback function in the client to render the updates.

If you want full duplex communication between client and server then two connections are required. One for the client-to-server communications and the other for the server-to-client communications. With browsers often supporting up to two connections for a server this can be a big limitation. So you need to use this approach carefully. Otherwise you can run into some interesting problems.

HTML 5

HTML 5 Server Sent Events (SSE)
SSE standardizes the Comet styles of communication between client and server. It adds a new DOM element and the following new tag to support it.

<eventsource src="http://myserver/dosomething" onmessage="alert(event.data)">

There is also a programmatic way to create this.
var es = document.createElement(”eventsource”);
es.addEventListener(”message”, callbackmethod, false);
es.addEventSource(”http://myserver/dosomething” );
document.body.appendChild(es);

Once the server has data it will stream it to the call back method registered above. As per the spec the events have a reconnection time. The browsers should check with the server for data updates once the reconnection time has elapsed.

HTML 5 Web Sockets
Web Sockets allow for full-duplex communication over a single connection and the API is exposed via JavaScript. The API is quite simple as can be seen from the example below:

var myconn = new WebSocket("ws://myserver/something");
myconn.onopen = function(event) { }
myconn.postMessage("my message");
myconn.onread = function(event) { // u can read event.data) }
myconn.onclose = function(event) { }

The above is quite self explanatory. ws:// stands for web socket connection and wss:// represents the secure connection.

Web Socket implementations are not yet out there. That is especially the case with HTML 5 still not being official yet. Hopefully in the coming months we will have more widespread support for this. Remember for this to work there needs to be support on the browser as well as the web server.

Adobe Flex - Part 2

2009-07-22T20:18:00Z

I modified the previous Flex example app to implement the following:

Separated out related code into different physical files.
Created the src/components folder to hold reusable UI components in their respective .mxml files.
Created a new Class called Movie (file name Movie.as) in a package named dto. This class will hold the values of our grid properties. We will load the XML into instances of this class and collect them in a ArrayCollection.
Finally we use some validators in our form to validate that both movie name and rating are entered. Unless entered (as valid) the Add Movie button will NOT be enabled.

To create a reusable component right click on the src folder in Flex Builder and create a new Flex Component. Put the code in there(minus the mx:Application) and voila you have a reusable component.When you read the code notice how parameters are defined in the component files and then passed in from the root SecondFlexApp.mxml file.
Here is the new version of the SecondFlexApp.mxml file...

<?xml version="1.0"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" xmlns:comp="components.*" initialize="initApp()">

   <mx:Script>
		<![CDATA[
			import dto.Movie;
			import mx.controls.Alert;
			import mx.collections.ArrayCollection;
		

            [Bindable]
            public var movieList:ArrayCollection;

            public var moviexml:XML = 
		      <movies>
			       <movie>
				     <name>Angels & Demons</name>
				     <rating>1</rating>
				   </movie>
				   <movie>
				     <name>Ice Age 3</name>
				     <rating>2</rating>
				   </movie>
				   <movie>
				     <name>Transformers: Revenge of the Fallen</name>
				     <rating>3</rating>
				   </movie>
		      </movies>;	
      		
            public function initApp():void {
                movieList = new ArrayCollection(); 
                for each (var movie:XML in moviexml.movie) {
                    var mv:Movie = new Movie();
                    mv.name = movie.name;
                    mv.rating = movie.rating;
                    movieList.addItem(mv);
                }
                movieGrid.initApp();
            }
       ]]>
	</mx:Script>	
	

	<mx:VBox width="50%">
	   <mx:Label color="blue" text="Movies I have seen..."/>
	   <comp:MovieGrid id="movieGrid" movieList="{movieList}" width="100%"/>
	   <comp:addmovieform movieList="{movieGrid.movieList}"/>
	</mx:VBox>
		
</mx:Application>

The new xmlns:comp namespace which refers to the components folder (components.* allows us to refer to all components in the src/components folder.
We pass in references to values in the mx:VBox such as in comp:MovieGrid we pass in the movieXML parameter into the component.
The mx:VBoxis a layout container that places components vertically (there is an mx:HBox too if you want).
In the initApp method I iterate through the XML , create Movie instances and add them to the movieList ArrayCollection.

The Movie class is:

package dto {
	public class Movie {
		public var name:String;
		public var rating:Number;
		
		public function Movie() {
		}
	}
}

The complete Flex Archive can be downloaded here secondflexapp.zip

The running app with validation ON looks like this...

Adobe Flex - Part 1

2009-07-22T12:20:00Z

Adobe Flex is a framework/sdk provided by Adobe that allows us to build rich internet applications (RIA) using Flash as the underlying technology.

Web designers have been using Flash to design apps for the web for a longtime. But the approach to designing with Flash directly is not that conducive to mainstream application development. Thus Flex was created. Flex provides a programming platform which is more easily understood by application developers as compared to Flash. Flex uses two programming languages to achieve this.

MXML - is an XML based programming model to define your UI layout.
ActionScript - is an implementation of ECMAScript (javascript2.0)

While MXML is used to define the UI elements, ActionScript is used to put in the behavior logic. This allows us to separate UI vs controller code. Let us run through an example to get a quick intro. This example is a little more involved than a standard hello but simple nevertheless.

Applications coded in Flash or Flex are executed in the browser using the Flash Player. There is another runtime called the AIR which is used to execute the applications outside of the browser as standalone desktop applications. Which one you use will depend on your application needs. For this tutorial we will use the browser to run the applications.

What You Need to Install
Flex 3 downloads are available from http://www.adobe.com/products/flex/flexdownloads/.

You can download the Flex SDK free of charge. But then you would have to use the command line or some other editor to code the application. Instead I would strongly recommend you download the trial version of Flex Builder 3 Eclipse Plugin. If you have an existing eclipse setup then installing the plugin is the preferred way. After 30 days you have to buy this product. I personally feel that Adobe has priced the product too high for regular developers and I hope they provide a free version for development soon.

I also suggest going through the tutorial at http://www.adobe.com/devnet/flex/videotraining/. I found this very useful and strongly recommend it for folks new to Flex.

Whatis the App?
The application is your personal movie tracker. It shows a grid with a list of movies you have watched and what rating you gave them. You can delete movies from the Grid or add new movies to the grid using a simple form.

Creatinga Basic Project
Once the Flex Builder3 plugin has been installed open up the Flex Debugging perspective and you should see something like this:

Now create new Flex project and name it 'FirstFlexApp'. This will create a project with the following structure:

.actionScriptProperties, .flexProperties contain various Flex related configuration.
.project is the Flex eclipse project configuration.
By default Flex Builder created a FirstFlexApp.mxml file. This is what you will run to execute your application.

Even though we have MXML to code the UI layout, you must be aware that MXML is converted to ActionScript during compile time. So it is entirely possible to build your application using ONLY ActionScript. But it would make it much harder to do so. Our application MXML code starts with...

<?xmlversion="1.0"?>
<mx:Applicationxmlns:mx="http://www.adobe.com/2006/mxml"creationComplete="initApp()">
...
</mx:Application>

The creationComplete hook is optional. We use it here to call afunction which will retrieve the current movie list (as XML) and thenpopulate the grid with the contents. creationComplete is invoked afterthe layout has been prepared and displayed. There is another hookcalled initialize which can be used instead. initialize calls afunction before the UI is displayed.

Next we add the initial XML data here as:

<mx:XMLList id="moviexml">
   <movie>
     <name>Angels&Demons</name>
     <rating>1</rating>
   </movie>

   <movie>
     <name>Ice Age3</name>
     <rating>2</rating>
   </movie>

   <movie>
     <name>Transformers:Revenge of theFallen</name>
     <rating>3</rating>
   </movie>
</mx:XMLList>

mx - is the namespace used to identify the MXML elements. XMLLIst is an alias for a ActionScript class. Following that are various properties/methods that you want to configure for this class. In this case id is used to give a unique name to this instance of XMLList. Here we setup 3 movies. There are no remote calls in this tutorial to make things easier.

Next here is the rest of the UI layout:

    <mx: Panel title="Movie List" height="100%" width="100%" 
        paddingTop="10" paddingLeft="10" paddingRight="10">

        <mx:Label width="100%" color="blue"
            text="Movies I have seen..."/>

        <mx: DataGrid id="movieGrid" width="50%" height="50%" rowCount="4" resizableColumns="true" editable="false" >
            <mx:columns>
                <mx: DataGridColumn dataField="name" headerText="Name"/>
                <mx: DataGridColumn dataField="rating" headerText="Rating" />
				<mx: DataGridColumn width="40" sortable="false" fontWeight="bold">
				    <mx:itemRenderer >
						<mx:Component>
                                                // refer to full listing for code here
						</mx:Component>  
				    </mx:itemRenderer>
				</mx: DataGridColumn>            
            </mx:columns>
        </mx: DataGrid>
        
        <mx: Panel width="359" height="170" layout="absolute">
            <mx:Label x="10" y="10" text="Movie Name:"/>
            <mx:Label x="42" y="36" text="Rating:"/>
            <mx:TextInput x="96" y="8" id="fldMovieName"/>
            <mx:TextInput x="96" y="34" width="25" id="fldMovieRating" maxChars="1"/>
            <mx:Button x="69" y="76" label="Add Movie" click="addMovie()"/>
        </mx: Panel>
        
    </mx: Panel>

We define a label and then a data grid to display the XML data. The mxataGridColumn is used to define the columns in this table. Our 3rd column is a special non-data column which will display an X symbol to delete a row. The code for that can be seen in the full listing at the end. You can also see the text form to enter new movies. The mx:Button uses its click property to connect the click event to the addMovie function.

Finally here is the ActionScript code to bind the grid to the XML data.

<mx:Script>
<![CDATA[
   import mx.collections.XMLListCollection;
   import mx.controls.Alert;


   [Bindable]
   private var movieList:XMLListCollection; 
            
   public function initApp():void {
      movieList = new XMLListCollection(moviexml); 
      movieGrid.dataProvider = movieList;
   }

   private function addMovie():void {	        	
      if ( fldMovieName.text == "" || fldMovieRating.text == "") {
         Alert.show("Enter valid values for movie and rating.","Alert");
      }
      else {
         movieList.addItem(
           
              {fldMovieName.text}
              {fldMovieRating.text}
            );
      }
   }
]]>
</mx:Script>

The sample above is quite self-explanatory. The initApp creates a XMLListCollection and references that to the movieGrid.dataProvider.

Run the eclipse application and here what you will see in the browser:

Click on firstflexapp.zip to download the complete Flex Project Archive. You can export a Flex Archive by right clicking on the browser and performing an Export to Flex Archive (a zip file).

Facelets

2009-06-16T23:34:00Z

Facelets is a JSF framework to implement UI templating (like tiles,sitemesh). You can use Tiles to implement the templating portion but Facelets is built for JSF.

In addition to the templating feature you can also create reusable components using Facelets and if you like Tapestry then you can make use of a similar feature with Facelets wherein rather than using jsf tags in the JSP you can use jsfc to indicate the component you plan to use. Example:

<input type="text" jsfc="h:outputText" value="Printed using Using jsfc .. like Tapestry" />

Note:I put this example together quite some time back but forgot to publish this earlier. Now straight to an example. I assume a certain knowledge of JSF as required. If not sure you can download the complete working zip file and get an idea for yourself regarding JSF and Facelets.

First of all you create the template.xhtml which will define the layoutfor our application:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN""http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
     xmlns:h="http://java.sun.com/jsf/html"
     xmlns:f="http://java.sun.com/jsf/core"
     xmlns:ui="http://java.sun.com/jsf/facelets">
<head>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1" />
<title>Test Faceletswebapp</title>
</head>

<body>
   <h3><ui:insert name="title">DefaultTitle</ui:insert></h3>
   <hr />
   <p>
     <ui:insert name="body">Default Body</ui:insert>
   </p>
   <br />
   <br />
   <hr />
</body>
</html>

The above illustrates a very basic example. In the zip file I do no use the above template, instead the zip file has more elaborate layout.

<ui:insert name="title"> : Creates a placeholder to drop page titles.
<ui:insert name="body"> : Creates a placeholder to drop page content.

Now here is my content page index..xhtml:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
                     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
     xmlns:ui="http://java.sun.com/jsf/facelets"
     xmlns:h="http://java.sun.com/jsf/html"
     xmlns:f="http://java.sun.com/jsf/core"
     xmlns:t="http://myfaces.apache.org/tomahawk">
<head>
<title>Notes</title>
</head>

<body>
<ui:composition template="/template.xhtml">
      <ui:define name="title">Facelet works</ui:define>
       This text will also not be displayed.

      <ui:define name="body">
          <h:form>
                 <h:commandLink value="Display All Notes" action="toNotes"/>
           </h:form>
     </ui:define>
</ui:composition>
</body>
</html>

<ui:composition template="/template.xhtml"> : The composition tagis used to identify the template to be used for this page.
<ui:define name="title"> : The ui:define tag is used here toinsert the page title
<ui:define name="body"> : The ui:define tag is used here toinsert the page contents.

The web.xml is:

<?xml version="1.0"encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

">java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

     <context-param>
           <param-name>javax.faces.DEFAULT_SUFFIX</param-name>
           <param-value>.xhtml</param-value>
     </context-param>

     <context-param>
           <param-name>facelets.DEVELOPMENT</param-name>
           <param-value>true</param-value>
     </context-param>

     <servlet>
           <servlet-name>Faces Servlet</servlet-name>
           <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
           <load-on-startup>1</load-on-startup>
     </servlet>

     <servlet-mapping>
           <servlet-name>Faces Servlet</servlet-name>
           <url-pattern>*.faces</url-pattern>
     </servlet-mapping>
</web-app>

Finally the faces-config.xml:

<?xml version="1.0"encoding="UTF-8"?>
<faces-config version="1.2"xmlns="http://java.sun.com/xml/ns/javaee"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/javaeejava.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd" style="color:teal;">>

     <application>
           <view-handler>com.sun.facelets.FaceletViewHandler</view-handler>
     </application>

     <navigation-rule>
           <from-view-id>/index.xhtml</from-view-id>
           <navigation-case>
                 <from-outcome>toNotes</from-outcome>
                 <to-view-id>/notes.xhtml</to-view-id>
           </navigation-case>
     </navigation-rule>
</faces-config>

com.sun.facelets.FaceletViewHandler is the what does the templating magic.

Here is the screenshot of the home page:

Clicking on Display All Notes will take you to the notes.xhtml page which is another static page with different content.

You can download the complete example by clicking here - faceletss.zip. Having done all of this I must say though that SiteMesh still remains my favourite templating engine. Not sure if it will work with JSF though.

REST with JAX-RS

2009-05-02T09:52:00Z

REST (REpresentational State Transfer) is an architecture style that describes how to use the Web (HTTP) to access services. JAX-RS (JSR 311) isa Java API to support implementation/access of REST web services using Java. This style was first documented by Ron Fielding.

There will be times we use REST principles without even knowing that we use REST (that is a mouthful). Ever since HTTP came around the largest REST implementation is the web itself.

REST prescribes that all services be treated as resources that can be accessed via a URL. Thus the web is REstful.
REST also requires the services to be stateless.
REST does NOT describe any common data exchange formats. The producer and consumer are free to choose whatever format they can agree on.
REST services in many cases are cacheable (though I think in many business cases it is not and thats just fine).
REST is commonly used over HTTP (though since it is an architectural style one can use the same principles on any transport).

Used over HTTP the following HTTP methods can be used:

GET to retrieve data.
DELETE to delete.
INSERT to add new data
PUT to update data.

Now compare all of this to SOAP based web services where you use a WSDL to publish your interface, we have the SOAP envelope that carries the payload and can optionally provide many services such as transaction,security, addressing, etc (basically the WS-* nightmare). But often we just need to access a simple service without the need for all of the SOAP complexity.. That is where the RESTful architecture style comes in.

On the Java side JAX-RS was introduced to provide a common API to implement/access REST based services in Java. Jersey is the open source reference implementation of REST. Lets get to an example and see how this works. I will implement my usual time service. Call a service to get time of the day in XML, plain text or JSON format.

In Eclipse create a dynamic web project. Here is my layout.

Here is the web.xml...

<?xml version="1.0"encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns="http://java.sun.com/xml/ns/javaee"xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
">java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">
   <display-name>jaxrs</display-name>

    <servlet>
       <display-name>jaxrs tryout</display-name>
       <servlet-name>jaxrsservlet</servlet-name>
       <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
       <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
       <servlet-name>jaxrsservlet</servlet-name>
       <url-pattern>/services/*</url-pattern>
    </servlet-mapping>
</web-app>

Here is the implementation of the TimeOfTheDayService. I usethe JAX-WS annotations to configure various JAX-RS attributes.

package com.tryout;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;

@Path("/timeoftheday")
public class TimeOfTheDayService {

     private static String PATTERN = "MM.dd.yyyy HH:mm:ss";

     @GET
     @Produces("text/plain")
     @Path("/asplaintext/{name}")
      public String getTimeOfTheDay(@PathParam("name") String name) {
           SimpleDateFormat df = new SimpleDateFormat(PATTERN);
           return name + "-" + df.format(Calendar.getInstance().getTime());
      }

     @GET
     @Produces("application/xml")
     @Path("/asxml/{name}/")
      public Time getTimeOfTheDayInXML(@PathParam("name") String name) {
           SimpleDateFormat df = new SimpleDateFormat(PATTERN);
           Time t = new Time();
           t.setName(name);
           t.setTime(df.format(Calendar.getInstance().getTime()));
           return t;
      }

      @GET
     @Produces("application/json")
     @Path("/asjson/{name}/")
      public Time getTimeOfTheDayInJSON(@PathParam("name") String name) {
           SimpleDateFormat df = new SimpleDateFormat(PATTERN);
           Time t = new Time();
           t.setName(name);
           t.setTime(df.format(Calendar.getInstance().getTime()));
           return t;
      }
}

@Path("/timeoftheday") - Specifies the URI part for all the services in thisclass.
@GET- Used to annotate the read method.
@Produces("text/plain")- Marks the method as a producer of plain/text content.
@Path("/asjson/{name}/") - Describes the specific method. The optional {name} describes in our case the parameter passed into this service method.

The URL to access the services would be one of:

http://localhost:8080/jaxrs/services/timeoftheday/asplaintext/mathew
http://localhost:8080/jaxrs/services/timeoftheday/asxml/mathew
http://localhost:8080/jaxrs/services/timeoftheday/asjson/mathew

The resource is identified via the URL and so is the parameter name inthis example.

The Time javabean class is:

package com.tryout;

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "clock")
public class Time {

      @XmlElement
      private String time;

      @XmlElement
      private String name;

      public void setTime(String time) {
           this.time = time;
      }

      public void setName(String name) {
           this.name = name;
      }
}

Deploy the web application. I used the embedded Tomcat instance in Eclipse to run this example. Access one of the URLs mentioned earlier and you will get the response in the appropriate format.

You can also use the jersey client API to access this service...

package com.tryout;

import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.WebResource;

public class JSONClient {

      public static void main(String[] args) throws Exception {

           Client c = Client.create();

           //
           WebResource r = c
                       .resource("http://localhost:8080/jaxrs/services/timeoftheday/asplaintext/mathew");
           System.out.println("Plain Text=>> " +r.get(String.class));

           //
           r = c
                       .resource("http://localhost:8080/jaxrs/services/timeoftheday/asxml/mathew");
           System.out.println("XML=>> " + r.get(String.class));

           //
           r = c
                       .resource("http://localhost:8080/jaxrs/services/timeoftheday/asjson/mathew");
           r.accept("application/json");
           System.out.println("JSON=>> " + r.get(String.class));
      }
}

Once you execute this client you should get a response such as:

Plain Text=>>mathew-05.02.2009 08:31:35
XML=>><?xml version="1.0" encoding="UTF-8"standalone="yes"?><clock><time>05.02.200908:31:35</time><name>mathew</name></clock>
JSON=>> {"time":"05.02.2009 08:31:35","name":"mathew"}

Pretty simple ah! Enjoy.

Apache Camel

2009-03-25T03:03:00Z

Apache Camel is an integration framework that supports and implements various integration related patterns. This article goes over a basic example which will give the reader a decent beginning to Camel.

Camel touts itself as "a powerful open source integration framework based on known Enterprise Integration Patterns with powerful Bean Integration." These Enterprise Integration Patterns are documented in the book by Gregor Hohpe and Bobby Woolf. The specific patterns that Camel supports can be found at Camel Patterns.

Note: Camel is used as part of IONA's FUSE ESB product. FUSE also uses ServiceMix, CXF and ActiveMQ.

One of the key features of an ESB is to allow heterogeneous applications to talk to each other in a location independent way. What this means is that App1 does not talk to App2 directly (point-2-point). Instead they communicate via a common medium, the message bus. App1 puts a message on the bus requesting a certain service. The bus looks at the message header and routes it to the appropriate endpoint. The endpoint in this case is App2. Neither App1 nor App2 are directly tied together anymore.

Apache Camel provides the routing and mediation capabilities. Using URI's we define where we want to send the messages to. Example from our sample below - jms:queue:customer. This indicates that we are dropping a message to a jms queue named customer. The bus then routes the message appropriately to the endpoint. In the case of Camel we can set up the routing in either Java DSL (Java api) or via Spring XML. In this blog I use Java DSL (Spring XML is just as easy).

In the example below I implement the following:

The client (consumer) needs to call a remote service (provider) to get customer information (including any available rebate information)
The client does not know who the provider is.
The client only knows that it can drop a message into the bus with the customer id and it will get back a Customer java object.
On the ESB itself there are two services in play. The first service returns basic customer information. Another independent service returns the rebates based on the customer type (preferred customer or regular customer).
On the ESB we need to wire these two services together to provide the complete customer.
Finally my example takes the liberty of hardcoding certain values such as customer id and account id to only focus on Camel.

For this blog I will not post every single code file but describe the key parts. I will attach a zip file containing the complete maven project.

First the simple AccountService implementation...

package com.aver;
import org.springframework.stereotype.Service;
@Service(value = "acctsvc")
public class AccountServiceImpl implements AccountService {

    public Boolean isActive(String acctId) {
        System.out.println("Invoked isActive with " + acctId);
        return acctId.equals("12345") ? true : false;
    }
}

Next the CustomerService implementation...

package com.aver;
import org.springframework.stereotype.Service;
@Service(value = "custsvc")
public class CustomerServiceImpl implements CustomerService {
    public Customer getCustomerInfo(String custid) {
        System.out.println("Invoked getCustomerInfo with " + custid);
        Customer c = new Customer();
        c.setCustId(custid);
        if (custid.equals("cust1")) {
            c.setAcctId("12345");
            c.setName("activecustomer");
            c.setType(Customer.Type.PREFERRED);
        } else {
            c.setAcctId("09876");
            c.setName("inactivecustomer");
            c.setType(Customer.Type.REGULAR);
        }
        return c;
    }
}

As you can see the CustomerService has nothing to do with the rebate information.

Next is the Rebate implementation...

package com.aver;
import org.springframework.stereotype.Service;
@Service(value = "rebatesvc")
public class LoyaltyRebateServiceImpl implements LoyaltyRebateService {

    public Customer rebates(Customer c) {
        if (c.getType() == Customer.Type.PREFERRED) {
            Rebate r = new Rebate("50% off all java 1.2 books");
            c.getRebates().add(r);
        }
        return c;
    }
}

Next we need to tell Camel what our routes are. For this blog I use the Java DSL and implement a RouteBuilder.

ServerRoutes (RouteBuilder)...

package com.aver;
import org.apache.camel.builder.RouteBuilder;
public class ServerRoutes extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        from("jms:queue:customer").to("custsvc").to("rebatesvc");
        from("jms:queue:account").to("acctsvc");
    }

}

Here we route the messages coming to the customer queue to the customer service and then to the rebate service.

Next we create the camel-server.xml (in META-INF/spring folder)...
The spring xml below sets up the Camel Context, the ActiveMQ JMS and configures Camel to use ActiveMQ.

    <!-- use spring annotations -->
    <context:component-scan base-package="com.aver" />

    <!-- camel context -->
    <camel:camelContext id="camel">
        <camel:package>com.aver</camel:package>
    </camel:camelContext>


    <!-- configure ActiveMQ -->
    <broker:broker useJmx="false" persistent="false"
        brokerName="localhost">
        <broker:transportConnectors>
            <broker:transportConnector name="tcp"
                uri="tcp://localhost:61616" />
        </broker:transportConnectors>
    </broker:broker>

    <!-- configure Camel to use the ActiveMQ broker -->
    <bean id="jms" class="org.apache.activemq.camel.component.ActiveMQComponent">
        <property name="brokerURL" value="tcp://localhost:61616" />
    </bean>

The Client...
com.aver.client.Client contains following code that mimics a caller. There also exists a camel-client.xml (please see the zip file).

// simple
Boolean response = (Boolean) camelTemplate.sendBody(
         "jms:queue:account", ExchangePattern.InOut, "12345");
System.out.println("Account Active Flag: " + response);

// returns java object
Customer c = (Customer) camelTemplate.sendBody("jms:queue:customer",
         ExchangePattern.InOut, "cust1");
System.out.println("Customer : " + c);

The client code in this case has no idea about the service classes or actual endpoint. It only knows how to address the service in the bus using URI's such as 'jms:queue:account". Camel then routes this to the actual endpoint.

Running this....
Run maven command

mvn clean compile exec:java -Dexec.mainClass=org.apache.camel.spring.Main (this will bring up the Camel runtime so you can test).
From your eclipse project run Client.java as a regular java application (after you have started Camel server).

Click here to download the zip file containing the code.