I have been a Java Developer for about 4 years but never really created a very simple website and hosted it. During my work experience I have been involved in much more complex back end systems with front ends in ICEfaces or GWT.

Need

I have seen quite a few websites created in WordPress, Joomla and Drupal. These technologies seem to be a good alternative in that we can do the following:

1. Quickly create a website
2. Train relatively inexperienced users to add content
3. Sit back and let the “super user” add the content

Creating a Website

Before designing a website the following needs to be considered:

1. Type of Website – Static or Dynamic (weekly / daily updates)
2. Budget – Yes this is very important, how much time will be spent on initial Setup and will there be a dedicated resource to update the site
3. Domain costs
4. Identify technology based on points 1 and 2, CMS type technologies like Joomla or Drupal can be good and bad
5. Hosting costs – Linux or Windows
6. Who is going to host the website – Shop around and find a good provider best suited to your technology
7. User training, if the user is going to be adding content or accessing reports
8. Maintenance and Support – Who will maintain this website

A while back I added an article on EasyMock and since then I have gained some more insight into Unit Tests.

During this period the importance and benefits of unit tests have been highlighted to me in practice.

A Senior Developer gave me two good phrases (actually they came from two Senior Developers)

1. A good unit test is if one line of code is changed atleast one unit test fails.

2.  If your unit test becomes quite complicated, it is a sure sign that your method is too complicated.

What are Unit Tests?

During my graduate and post graduate studies the emphasis on testing, let alone unit testing was very minimal. In the working world at times this is also left out / reduced due to time / budgeting constraints.

To me a unit test is a test that tests one way the method could be executed.

Benefits

So we have a unit test (a method that tests our method) , this brings about two benefits:

1. Ensures method does what we expect it to do

2. Ensures that if we make changes to the method, it still does what we expect it to do. If it does not we have to fix it by either updating the method or the unit test itself to cater for the new requirement.
Summary

As a Java Developer, developing both the front end (using ICEfaces ) and back-end writing unit tests for these types vary. Back-end code usually requires the mocking of the database whilst front-end requires mocking of these business services. Yes they might seem a bit different but the aim is the same.

I would like to actually discuss more of the benefits as it has come to me in several ways over the past weeks after we began intensifying our campaign on increasing the amount of unit tests we write per method. In a modular section based team, where one group is responsible for the front-end, other back-end (could be split up) can cause the one team to wait on the other. Resulting in the possible loss of revenue, however if good unit tests are created per development team, the other can go on and be 90% sure their code is correct and reduce the time they need to go back and fix things as well as not be held up.

Ok that was just some of my points on Unit tests, will have some more, with Java examples soon.

Blog Soon!

A key component to any piece of code is its corresponding unit test.  Let us start with my problem.

The Problem

I created a few tables using hibernate, this involved setting up the .hbm.xml mapping file as well as corresponding java classes. A unit test was created per table to confirm that each table can be accessed correctly. That is all fine, but the project I am currently on uses the Model View Controller (MVC) framework, this beautiful framework splits our design into the following:

1. Database

2. Business Logic

3. Front-End

Ok, we have completed the Database layer, now we dealing with the business logic. The main aim of the business logic would be to provide the front-end with data from the database. Let us assume we created a class that allows us to get the data from the database (rather since we using test driven development, created the interfaces and then create our unit test). So you are wondering, where does EasyMock come in? Well I never knew either, but after having a few discussions with others and reading up:

http://easymock.org/EasyMock2_2_Documentation.html

http://www.michaelminella.com/testing/unit-testing-with-junit-and-easymock.html

EasyMock 2 is a library that provides an easy way to use Mock Objects for given interfaces

So you ask what is the benefit of this?

1. Reduces the need to actually access the database, thereby reducing the time it takes to run the unit test
2. Guaranteed return values, otherwise an error is displayed

To me that are the basic and very important benefits.

How does it work?

EasyMock allows you to set up a “recording” then actually “running” then “verifying”  the recording against the run.

That is my basic introduction into EasyMock, let me get into some more examples.

Blog soon!

Background

I have recently begun working with ICEfaces and Fusion Charts in order to render various types of charts.

The model used is as follows:

• Chart data element storing chart specific data
• Chart generator that uses xstream to convert this chart data into XML.

We then created chart data and a generator per type of chart. Eg. Piechart data and piechart XML generator.

So now when we want to get a specific generator we need to actually do the check to see what type of chart we have then determine the generator.  The check could look something like this:

Chart chart // this could be any subclass, such as a PieChart

if (chart instance of PieChart) {

return PieChartXmlGenerator;

} else if (chart instance of LinearGaugeChart) {

return LinearGaugeChartXmlGenerator;

} .....

....

....

This can become cumbersome since each time we require a specific generator we need to do this check.

Analogy

When trying to think of the best analogy to describe this pattern I thought about the building contractor relationship. Lets say I want to tile my bathroom, I would inform my contractor about this and he would bring me a tiler. If I wanted to build some cupboards he would bring me a carpenter. Simple enough? In this analogy the contractor is our “factory”. We simply specify what we looking for and the “factory” returns what we need to get the task done.

Example

The code above where we did the “instanceof” check could all be moved into a Factory like this:

public class ChartXmlGeneratorFactory {

 public static ChartXmlGenerator getChartXmlGenerator(Chart chart) {
 if (chart instanceof PieChart) {
    return new PieChartXmlGenerator();
 } else if (chart instanceof LinearGaugeChart){
   return new LinearGaugeXmlGenerator();
 } // add new ChartGenerator selections here
   throw new IllegalStateException("The chart returned does not match any of the implemented Chart Types");
 }
}

Then when we want to actually use the factory we would just call it like this:

PieChart pieChart = new PieChart();
PieChartXmlGenerator chartXmlGenerator = (PieChartXmlGenerator) ChartXmlGeneratorFactory.getChartXmlGenerator(pieChart);

I omitted defining PieChartXmlGenerator   but I hope you get my point. This is the nice way of simply saying to your factory I want to do this and your factory says use this to do what you require.

This is the Java version of our factory, I am getting to grips with Spring and will post about the Spring alternative to this. Its really very good.

Please feel free to post any comments or suggestions you may have. Again I would like to reiterate that I am no expert in this topic but simply documenting my journey of discovery.
Blog Soon!

Your feedback is therefore most valued and appreciated. Today we will be looking at Maven, an amazing and “magical” technology (I think I might be shot for using the word “magical” ).

The Basics

Back in the day when we simply needed to create simple Java projects with very little library dependencies it was very simple, point to your JDK and import your required libraries. Off we would go coding our main class that would use other classes.

That was all and well (sometimes still a pain setting up the libraries though), but now what happens when we working on a bit larger project where we have much more external dependencies on libraries.  How do we link everything up?

Maven ( http://maven.apache.org/ ) has the answer to this (as well as the answer to some other issues as well.  In the words of the creators of Maven this is how they describe Maven is an attempt to “apply patterns to a project’s build infrastructure in order to promote comprehension and productivity by providing a clear path in the use of best practices.”

That might sound a bit confusing but as we get into the features of Maven we will realise that it does in fact provide and promote a common build infrastructure. A list of Maven features include:

• Builds
• Documentation
• Reporting
• Dependencies
• SCMs
• Releases
• Distribution

Project Object Model (POM)

I think the best way to explain how Maven achieves this is by introducing the Project Object Model (POM) file.  Since Maven 2 the project.xml has been renamed to pom.xml.

This pom.xml is where all the magic happens. Let us look at a sample POM file from Maven website:

xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0
 <groupId>com.mycompany.app
 <artifactId>my-app
 <packaging>jar</packaging>
 <version>1.0-SNAPSHOT</version>
 <name>Maven Quick Start Archetype</name>
 <url>http://maven.apache.org
 <dependencies>
 <dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>3.8.1</version>
 <scope>test</scope>
 </dependency>
 </dependencies>
</project>

I know it might seem a bit scary at first but this POM file really describes the essence of Maven and its ability to provide us with features such as build control to documentation management.

This is a copy of how Maven describes the common elements

• project This is the top-level element in all Maven pom.xml files.
• modelVersion This element indicates what version of the object model this POM is using. The version of the model itself changes very infrequently but it is mandatory in order to ensure stability of use if and when the Maven developers deem it necessary to change the model.
• groupId This element indicates the unique identifier of the organization or group that created the project. The groupId is one of the key identifiers of a project and is typically based on the fully qualified domain name of your organization. For example org.apache.maven.plugins is the designated groupId for all Maven plug-ins.
• artifactId This element indicates the unique base name of the primary artifact being generated by this project. The primary artifact for a project is typically a JAR file. Secondary artifacts like source bundles also use the artifactId as part of their final name. A typical artifact produced by Maven would have the form -. (for example, myapp-1.0.jar).
• packaging This element indicates the package type to be used by this artifact (e.g. JAR, WAR, EAR, etc.). This not only means if the artifact produced is JAR, WAR, or EAR but can also indicate a specific lifecycle to use as part of the build process. (The lifecycle is a topic we will deal with further on in the guide. For now, just keep in mind that the indicated packaging of a project can play a part in customizing the build lifecycle.) The default value for the packaging element is JAR so you do not have to specify this for most projects.
• version This element indicates the version of the artifact generated by the project. Maven goes a long way to help you with version management and you will often see the SNAPSHOT designator in a version, which indicates that a project is in a state of development. We will discuss the use of snapshots and how they work further on in this guide.
• name This element indicates the display name used for the project. This is often used in Maven’s generated documentation.
• url This element indicates where the project’s site can be found. This is often used in Maven’s generated documentation.
• description This element provides a basic description of your project. This is often used in Maven’s generated documentation.

If we look at the project or version elements we can see how this relates to releases and version control, whilst packaging relates to what type of output we would like Maven to output. Have a look at the above definitions and I hope this makes things a bit clearer as it has with me.

Thus far we have looked at some of the benefits / features of Maven and the POM file but not really spoken much about the actual framework and how it relates to our Java projects. That I will leave for my next post.

I hope this post gave you a brief introduction into Maven, the show is not yet over

Blog Soon!

The Need

To answer this question let me try to explain what XStream does. XStream allows you to convert a Serializable Java Object into XML. See the link yet? The reason why I needed this was to dynamically create Fusion Charts (that require parameters in XML)

The XStream website: http://xstream.codehaus.org/index.html proves to be a very useful resource. As a side note I have been quite impressed lately by vendor websites, it seems much more time and effort  being spent on actual documentation and that’s GREAT!

The Basics

Getting back to the topic at hand, so what does XStream allow us to do? Simply put generate XML from a Java Object. I am not too sure of how all it parses the objects but so far seems to work well.

Simple Example

As stated above the need for this came about as I required a dynamic piece of XML based on a Java object and since us Java Developers love objects XStream is a perfect partner.

I found working backwards help, define the way you want your XML to look. Since we want to create a basic Pie chart our XML needs to look like this:

<chart caption="Not Started">
 <set label="Not Started" value="25"/>
 <set label="Started" value="50"/>
 <set label="In Between" value="25"/>
</chart>

To do this I created two classes:

Chart.java

**
 * This class forms the basis of our chart
 */
import java.util.ArrayList;
import java.util.List;

public class Chart {
 private String caption;
 private String subCaption;
 private List labels = new ArrayList();

 public Chart (String caption) {
 setCaption(caption);
 }

 public void add(Entry entry) {
 labels.add(entry);
 }

 public List getContent() {
 return labels;
 }

 public String getCaption() {
 return caption;
 }

 public void setCaption(String caption) {
 this.caption = caption;
 }

 public void setSubCaption(String subCaption) {
 this.subCaption = subCaption;
 }

 public String getSubCaption() {
 return subCaption;
 }
}

Entry.java

public class Entry {
 private String label, value;
 public Entry(String label, String value) {
 this.label = label;
 this.value = value;
 }
}

These two classes provided us with the ability to create a chart and add entries to it (entries would be values). What we then required was a Main class to process this data.  You need to add the xstream-[version].jar to your build path. Download the jar from the following location: http://xstream.codehaus.org/download.html , select the XStream Core only

Sample Main.Java

import com.thoughtworks.xstream.XStream;

public class Main {

 /**
 *    <!--fc:renderHTML>
 */
 public static void main(String[] args) {

 XStream xStreamOne = new XStream ();
 xStreamOne.alias("chart", Chart.class);
 xStreamOne.alias("set", Entry.class);
 xStreamOne.addImplicitCollection(Chart.class, "labels");
 xStreamOne.useAttributeFor(Chart.class, "caption");
 xStreamOne.useAttributeFor(Chart.class, "subCaption");

 xStreamOne.useAttributeFor(Entry.class, "label");
 xStreamOne.useAttributeFor(Entry.class, "value");

 Chart chart = new Chart("Not Started");
 chart.setSubCaption("Sub caption is");
 chart.add(new Entry("Not Started", "25"));
 chart.add(new Entry("Started", "50"));
 chart.add(new Entry("In Between", "25"));

 xml = xStreamOne.toXML(chart);
 System.out.println(xml);
 }

}

This results in the required output:

<chart caption="Not Started">
 <set label="Not Started" value="25"/>
 <set label="Started" value="50"/>
 <set label="In Between" value="25"/>
</chart>

The main methods to note are these three:

xStreamOne.alias("set", Entry.class);
xStreamOne.addImplicitCollection(Chart.class, "labels");
xStreamOne.useAttributeFor(Chart.class, "caption");

WWW.ICEFACES.ORG

For further details have a look at this example: http://xstream.codehaus.org/alias-tutorial.html

Blog Soon!

Welcome back, as mentioned in my previous post (http://liyaqatm.wordpress.com/2010/01/21/icefaces-meets-fusion-charts/) on Fusion Charts, ICEfaces has its own built chart library and personally I think it works quite well. Have a look at a sample generated based on the code given in my previous post.

 <h3><ice:outputText value="Fusion Charts"/></h3>
     <ice:panelGrid>
 <ice:outputChart type="pie2d"
  chartTitle="Liyaqat's Chart"
  yaxisTitle="Years"
  xaxisTitle="Sector"
  xaxisLabels="IT, HR, Finance"/>
     </ice:panelGrid>



ICEfaces Chart

• Download the required .swf chart files, these files act as the “Chart Generator”
• Create ICEfaces Facelets Project
• Create a Sub Folder called Fusion Charts and place all your .swf files in it
• Create a DataFile.xml file containing the following data:

<set label=‘January’ value=’17400′ />

<set label=‘February’ value=’19800′ />

<set label=‘March’ value=’21800′ />

<set label=‘April’ value=’23800′ />

<set label=‘May’ value=’29600′ />

<set label=‘June’ value=’27600′ />

<set label=‘July’ value=’31800′ />

<set label=‘August’ value=’39700′ />

<set label=‘September’ value=’37800′ />

<set label=‘October’ value=’21900′ />

<set label=‘November’ value=’32900′ />

<set label=‘December’ value=’39800′ /></chart>

• In the main page (or wherever you desire to display the chart) add the following code: <ice:panelGrid>
  <!– Add the Fusion Charts Here –>
  <object classid=“clsid:d27cdb6e-ae6d-11cf-96b8-444553540000″ codebase=“http://fpdownload.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=8,0,0,0″ width=“900″ height=“300″ id=“Column3D” >
  <param name=“movie” value=“FusionCharts/Pie3D.swf” />
  <param name=“FlashVars” value=“&amp;dataURL=DataFile.xml”/>
  <param name=“quality” value=“high” />
  <embed src=“FusionCharts/Pie3D.swf” flashVars=“&amp;dataURL=Data.xml&amp;” quality=“high” width=“900″ height=“300″ name=“Column3D” type=“application/x-shockwave-flash” pluginspage=“http://www.macromedia.com/go/getflashplayer” />
  </object></ice:panelGrid>

  This will give us the following graph:

My first task I was asked to do was implement charts within our ICEfaces project. Having just joined the project they felt this would be a good learning curve so excuse me if these posts jump from basic introductions to a bit more complex topic.

ICEfaces Built-In Charts

Firstly, just to note ICEfaces does implement their own Charting libraries. A typical example of creating a simple chart in ICEfaces is as follows:

<ice:form>

<h3><ice:outputText value=” Charts”/></h3>

<ice:panelGrid> <ice:outputChart type=“pie2d“

chartTitle=“Liyaqat’s Chart” yaxisTitle=“Years”

xaxisTitle=“Sector”

xaxisLabels=“IT, HR, Finance”/>

</ice:panelGrid>

Fusion Charts

The built in charts look generally OK and do the job quite well, however our team has decided to use Fusion Charts (http://www.fusioncharts.com). So how does Fusion Charts work?

Again, I have just started using this technology so please excuse me and feel free to comment below. As far as I understand how it works is as follows. Fusion Charts provide you with a jsw file (that uses Adobe Flash and you would simply add this jsw file to you project the same way as you would add an image. This .jsw file is kind of the “chart generator”, what we would then to do is within our XHTML (or anyother scripting page) we would send the parameters to this jsw file and this would return a nice looking chart based on our input parameters.

Sounds fairly simple, but then again we always know things that are simple are not always that way. Now let me try and get some charts generated and I will get back to you with some samples.

WWW.ICEFACES.ORG

Blog Soon!

</ice:form>

Built-In Charts

The Advantage of this is that it allows you to work with xhtml as opposed to jspx. If you would like to read my previous ICEfaces post have a look here:

http://liyaqatm.wordpress.com/2010/01/20/icefaces-quick-review

Review

Thus far we have done the following:

• Brief ICEfaces introduction
• Setup our Eclipse environment
• Completed a sample ICEfaces tutorial

Being a Java developer for a few years I have briefly touched various technologies such as EJB’s, SWING, GWT, MyGWT (please note they might not all be related ) and after completing my first tutorial this technology felt very similar (kinda) to a recruitement home page i created using Velocity.
Just one minute, I know some guys will be saying what the heck am I on about, am I crazy? Well the similarities I draw from Velocity and this is the ability to inject beans into my front end and use them (with Velocity the objects seemed more at my disposal though)

This will be a short post as I just wanted to jott down my thoughts on what I have learnt thus far and what are the actual benefits I see (could be quite premature, actually is very premature to say) but  just my ideas on what it all involves.

Potential Advantages

• Quick creation of XHTML front ends
• Ability to link these front-ends to Java
• AJAX Push Updates
• Usage of well defined widgets
• Large Community with enough support

There are other advantages but the few mentioned above are just those that came to mind at this point.  Have a look at the ICEfaces website: www.icefaces.org and if you not registered register and have a look at their samples.  They occasionally lack some detail but once you get a few working you will be able to go through the others quite quickly.

Thats my thoughts for now, what I plan on doing is going through some more tutorials and will be sure to let you know how that goes.

WWW.ICEFACES.ORG

Blog Soon!

Well, thus far we have gotten a brief overview of ICEfaces. In theory it sounds very powerful with all these fancy terms such as AJAX Push and easy skinning. If you have not read my previous ICEfaces  post have a look here: http://liyaqatm.wordpress.com/2010/01/15/icefaces-the-meltdown/

Developers learn best (atleast I do) through practicals, so let us begin by setting up our development environment.

I will be using Eclipse Galileo. The first thing I did was add the Eclipse ICEfaces plugin by doing the following:

Installing the Eclipse Plugins

Select Help -> Install New Software

The Install dialog will open up, Select the Add button and the Add Site dialog will open

In the Add Site dialog add a Name of your choice something like ICEfaces Plugin and in the URL enter the following URL : http://www.icefaces.org/eclipse-updates/

After selecting this you should see a list of plugins, select all and next. This will install the required plugins and you will be prompted to restart Eclipse.

Installing the Libraries

We installed the required plugins for Eclipse now we need the libraries to actually provide us with the ICEfaces functionality. Since we using the amazing Eclipse we do not need to actually even do this seperately rather do it when we create a new project and Eclipse will allow us to download the required libraries, amazing I tell you! Beats my days on campus when I would need to actually figure out all these complexities and sometimes be stuck with jar / library issues.

Creating a Test Project

Requirements:

• Eclipse (used in this example)
• Tomcat 6
• Internet access ( to download the required libraries, else have them already saved)

Let us begin:

From Eclipse,

Select New-> Other -> Web -> Dynamic Web Project

Create New Project

Enter your project name, make sure the Dynamic Web Module version is set to 2.5 and configuration uses ICEfaces Project

Enter Project Name

Enter the project name and other details. We have setup the project name and server details now we get to the build path screen, leave it as is and select Next.

On the Web Module screen ensure that the Generate web.xml deployment descriptor is selected then select Next.

This takes us to the JSF Capabilities screen, this is where the smart stuff happenWe will require three libraries:

• ICEfaces Core Library v1.8.2
• JSF 1.2 (Sun RI)ICEfaces
• Support Library v1.8.2

Download Libraries

To add a library simply select the download library link and Eclipse will search for the required libraries. Out of this list select each library above and install individually (NOTE: Only one library is installled at a time, so you will have to go back to the download library link each time).Download Libraries

Select Next, then Finish. We have created our project that contains the required structures and sample homepage. To run the project we need to add a server by going to the Servers dialog.

List of existing servers

We add a general Tomcat V6 Server by going to

New -> Server

From this screen we select the our Tomcat Version 6 and Select Next. On the next screen we include our test project then select Finish.

Start the Server by right clicking on the server and selecting Start

Please ensure you have all your libraries in place else you will be getting some funny and more common java.lang.NoClassDefFoundError Exceptions.

Once all the issues (if any) are resolved entering http://localhost:8080/yourprojectname , where yourprojectname is the name you selected will result in the following test page being displayed: