Life in OpenSource World

Comparison between Open Source Service Registry and Repository

2012-04-09T13:54:00.002-07:00

Yesterday I was exploring WSO2 SOA Registry in detail and I noticed that some times when I was trying to add some WSDL and XSD files, application started generating internal exceptions, and there is no clear explanation of these exceptions.

At that point I decided to explore some more stable open source registries which we can use in our environment with minimal changes. During my research I explored following four registries in details and did some comparative analysis between these services

Mule Galaxy (http://www.mulesoft.org/galaxy)
WebSphere Service Registry and Repository (Not open source but high recommendations)
Membrane Registry (http://membrane-soa.org/soa-registry/)
WSO2 Governance Registry

Registry	Advantages	Disadvantages
Mule Galaxy	Light Weight, Easy Integration with Tomcat, Support WSDL, XSD and Spring Configuration	No Concept of Services. You can just use it as an artefacts repository
WebSphere Service Registry and Repository	Complete Registry and Repository software Price is less than 500GBP	Require Web sphere Application Server as a prerequisite which itself a very expensive software
Membrane	Built in SOAP Client, XML Schema Comparison, Periodically checks for availability of the service and raises events on availability changes	No concept of Repository You can’t add WSDL and XSD as a file. You need to define URL of your WSDL and XSD files Not ability to categorize services. No ability to write Service Description and details
WSO2	Designed to store, index, and manage enterprise metadata related to SOA artefacts. Includes versioning features Easy to configure Fully open source with active development community	Application Bugs.

As per my analysis WSO2 is most suitable product for our environment and based on our requirements. We need to live with its open bugs; at least we have an active development community for this product who can support in case of any code bug

Next step is to find answers of following questions. I tried to answer few of them

Is it possible to modify or customize WSO2 Registry based on our requirements?
Is there any special licensing required for Corporate or deployment in Production environment?
Is it possible to implement Role based Security?

Application supports Role based separation of actions and approval processes

Is it possible to integrate it with our existing development and operation tools?

IDE integration with Eclipse plug-in

Identify useful gadgets which we can integrate with application
Is it possible to enhance Governance Dashboard based on our organization requirements?
Is there any Reporting Mechanism available in the tool?
Is it possible to Plug-In with IDE?

IDE integration with WSO2 Carbon Studio, Eclipse plug-in, Microsoft Visual Studio

Is there any Automate approval or change management processes present in the tool?

Application supports Role based separation of actions and approval processes

Algorithms: Bubble Sort in Java

2011-12-07T05:45:00.001-08:00

Bubble sort, also known as sinking sort, is a simple sorting algorithm that works by repeatedly stepping through the list to be sorted, comparing each pair of adjacent items and swapping them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates that the list is sorted.

Although the algorithm is simple, it is not efficient for sorting large lists; other algorithms are better.

Worst case performance О(n²)

Best case performance О(n)

Average case performance О(n²)

where n is the number of items being sorted

Formula of Bubble Sort should be n(n-1). For 8 elements there should be 56 possible comparison

public class BubbleSort {

public static void main(String args[]){

int[] array={5,3,8,4,6};

printArray(array);

int comparison=0;

for(int j=0;j<array.length;j++){

for(int i=0;i<array.length-1;i++){

int a=array[i];

int b=array[i+1];

comparison++;

if(a>b){

array[i]=b;

array[i+1]=a;

}

System.out.println();

printArray(array);

System.out.println();

System.out.println(comparison);

}

public static void printArray(int[] array){

for(int i:array){

System.out.print(i+",");

}

WikiPedia has very good article about Sorting Algorithms

http://en.wikipedia.org/wiki/Sorting_algorithm

Patterns: Factory Method

2011-12-07T03:34:00.001-08:00

Factory Method

Purpose

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
Defining a “virtual” constructor.
The new operator considered harmful.

Facotry Method is a Creational Pattern and it deals with Creation of Object without specifying the exact class of object that will be created. Object creation some times requires complex processes not required and it’s not appropriate to write all this code in composing object

Facotry Method design pattern handles this problem by creation of a separate method for creation of object which Subclass can override to provide its own implementation

Essence of Factory Method Pattern is

“Define an interface for creating an object, but let the subclasses decide which class to instantiate. The Factory method lets a class defer instantiation to subclasses”

public class TestFactoryMethod {

public static void main(String[] args) {

Skin s=SkinFactory.getSkin("web");

s.printSkin();

}

class SkinFactory{

public static Skin getSkin(String type){

if(type!=null && type.equals("web"))

return new WebbasedSkin();

else

return new DesktopbasedSkin();

}

interface Skin{

public void printSkin();

}

class WebbasedSkin implements Skin{

public void printSkin(){

System.out.println("I am Web based Skin");

}

class DesktopbasedSkin implements Skin{

public void printSkin(){

System.out.println("I am DesktopbasedSkin Skin");

}

Important Concepts To Remeber during Written Java Test

2011-12-07T03:28:00.001-08:00

Point 1)

The code below is executed by "java -Dmyprop=myprop Test". Which two, placed instead of "//some code goes here", will produce the output "myprop"? (Choose two)

public class Test {
    public static void main(String args[]) {
        String prop = //some code goes here//
        System.out.print(prop);
    }
}

A) System.getEnv("myprop");

B) System.load("myprop");

C) System.property("myprop");

D) System.getProperty("myprop");

E) System.get("myprop");

F) System.getProperties().getProperty("myprop");

Answers: D, F
System.getProperty functions gets the system property indicated by the specified key.

Point 2)

Always Remember

A Static method can call other Static Methods in same class

A Static method can not call other Non Static Methods directly in same class

A Non Static Method can call static method directly

Point 3)

public class Room {
    public int roomNr;
    private Date beginDtm;
    private Date endDttm;

    public void book(int roomNr, Date beginDttm, Date endDttm) {
        this.roomNr = roomNr;
        this.beginDtm = beginDttm;
        this.endDttm = endDttm;
    }
}

The variable roomNr breaks encapsulation.

Point 4)

Object myObj = new String[]{"one", "two", "three"}; is valid declaration and initiation

Point 5)

public void waitForSomething() {
        SomeClass o = new SomeClass();
        synchronized (o) {
            o.wait();
            o.notify();
        }}

A) This code may throw an InterruptedException

B) This code may throw an IllegalStateException

C) This code may throw a TimeOutException

D) Reversing the ofrer of o.wait() and o.notify() will cause this method to complete normally.

Answer: A.
Object API:
public final void wait() throws InterruptedException

Point 6)

String s="abcd";

System.out.println(s.charAt(3));

Will print 3 because chatAt starts from 0

Point 7)

Given the code. What is the result?

import java.io.*;
public class Hotel implements Serializable {
    private Room room = new Room();

    public static void main(String[] args) {
        Hotel h = new Hotel();
        try {
            FileOutputStream fos = new FileOutputStream("Hotel.dat");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(h);
            oos.close();
        } catch(Exception ex) {
            ex.printStackTrace();
        }
    }
}
class Room {
}

A) Compilation fails.

B) An instance of Hotel is serialized.

C) An instance of Hotel and an instance of Room are both serialized.

D) An exception is thrown at runtime.

Answer: D.
java.io.NotSerializableException is thrown at runtime. All variables of a class being serialized must be serializable as well.

If Room become transient then its fine private transient Room room = new Room();

Point 8)

public static void main(String[] args) {

Integer[] a=new Integer[10];

printValue(a); // Problem here. Integer can not be passed in Double. Compile time error

}

public static void printValue(Double[] d){

System.out.println(d);}

public static void main(String[] args) {

Integer[] a=new Integer[10];

printValue(a); // Problem here. Integer can not be passed in Long. Compile time error

}

public static void printValue(Long[] d){

System.out.println(d);

}

Annotations in Spring

2011-10-06T04:18:00.000-07:00

Annotation in Java and Spring has made developer’s life very easy. To use Annotation in spring we need to add following tags in Spring Configuration file

<context:annotation-config/>

<context:component-scan base-package="com.spring.action"></context:component-scan>

By default, <context:component-scan> looks for classes that are annotated with one of a handful of special stereotype annotations:

@Component—A general-purpose stereotype annotation indicating that the class is a Spring component
@Controller—Indicates that the class defines a Spring MVC controller
@Repository—Indicates that the class defines a data repository
@Service—Indicates that the class defines a service
Any custom annotation that is itself annotated with @Component

Difference between @Service and @Component

They both belong to org.springframework.stereotype.Service

When annotating your class with @Component you mark it as a regular java component class when annotating with @Service you mark it as a “special” type of component for special purpose like transaction or associating with aspects.

@Autowired

Autowired is one of very important Annotation in spring

If we write

@Autowired

MyController c;

Its mean Spring will look for a class with name MyController If its an Interface then it will look for its implementer classes. If two classes have implemented this Interface and they both have @Component Annotation then Spring will generate exception

In this case you have two options

1) Option1

Give name to component like

@Controller("FirstController")

@Controller("SecondController")

In this case you have to define your variable like this

@Autowired

MyController FirstController;

@Autowired

MyController SecondController;

2) Option

Use Qualifier

@Controller("FirstController")

@Controller("SecondController")

and in your service use

@Autowired

@Qualifier("FirstController")

MyController c;

Another Example of Autowire

package com.spring.action.controller;

import org.springframework.stereotype.Controller;

@Controller

public class ThirdController implements MyController {

public boolean processMethod(String s){

System.out.println("Third Controller is processing Method");

return true;

}

When Spring scans the com.spring.action package, it’ll find that ThirdController is annotated with @Controller and will automatically register it in Spring. By default, the bean’s ID will be generated by camel-casing the class name. In the case of ThirdController that means that the bean ID will be thirdController.

We can use it in any of my class by writing

@Autowired

MyController thirdController;

The @Inject annotation from JSR-330

In an effort to unify the programming model among the various dependency injection frameworks, the Java Community Process recently published the Dependency Injection for Java specification. Known in the Java Community Process as JSR-330 or more commonly as at inject, this specification brings a common dependency injection model to Java. As of Spring 3, Spring supports the at inject model.2 The centre piece of JSR-330 is the @Inject annotation. This annotation is an almost complete drop-in replacement for Spring’s @Autowired annotation. So, instead of using the Spring-specific @Autowired annotation, you might choose to use @Inject on the instrument property:

Instead of @Qualifier Inject is using

@Inject

@Named("guitar")

private Instrument instrument;

Spring 3.0 introduced @Value, a new wiring annotation that lets you wire primitive values such as int, boolean, and String using annotations.

@Value("MySong")

private String song;

Sample Project is present at following location

https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0B0YFdqXJcI3mOWE0ZTFkODYtYWM4ZS00NzgyLWIyYzAtNTFkZWJkZTE4NTE4&hl=en_US

EhCache Integration with Spring and Hibernate. Step by Step Tutorial

2011-10-04T03:42:00.000-07:00

EhCache is a very popular open source caching framework widely used for Java based Caching.

Currently it’s owned by Terracotta.org and 2.5 beta releases is available for download.

In this article I just focused on EhCache Integration with Spring and Hibernate also I just explained few basic concepts which are required to understand Code. For detailed Caching Concepts Please visit http://ehcache.org/

Cache Manager, Caches and Elements are main entities of EhCache

EhCache consists of a CacheManager, which manages Caches. Caches contain Elements, which are essentially name value pairs. Caches are physically implemented either in-memory, or on disk.

Integration with Spring

EhCache integration with Spring is quite simple. You just need to define some properties in spring configuration xml file and its ready to use. Spring is using Annotation to integrate EhCache and by this we can add caching to any method results

EhCache Annotations for Spring is available via maven, simply add the following dependency to your pom.xml

 <!-- EhCache -->
 <dependency>
      <groupId>com.googlecode.ehcache-spring-annotations</groupId>
      <artifactId>ehcache-spring-annotations</artifactId>
      <version>1.2.0-M1</version>
 </dependency>
<!—CGLib is also required for EHCache -->
<dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>            
      <version>2.2.2</version>
</dependency>

Next Step is to perform changes in your spring Configuration file. Below is my Spring configuration file which contains EhCache configurations

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:context="http://www.springframework.org/schema/context" 
xmlns:mvc="http://www.springframework.org/schema/mvc" 
xmlns:p="http://www.springframework.org/schema/p" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:ehcache="http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring"   
xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd     
http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context-3.0.xsd    
http://www.springframework.org/schema/mvc 
 http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
  http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring 
  http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring/ehcache-spring-1.1.xsd">
          
    <context:component-scan base-package="com.eiconsulting"/>
    <mvc:annotation-driven  />
    <ehcache:annotation-driven cache-manager="cacheManager" />
    <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">   
         <property name="configLocation" value="/WEB-INF/ehcache.xml" />    
    </bean> 
</beans>

Important point to note here is that Cache Manager Name and its Configuration Location. We can use cacheManager in our code to store and retrieve information from Cache.

ehcache.xml file is configuration file for EhCache where we can define configuration details of EhCache. In my case here is content of my ehcache.xml file

<?xml version="1.0" encoding="UTF-8"?> 

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">    

    <defaultCache eternal="true" maxElementsInMemory="100" overflowToDisk="false" />           

    <cache name="customer" maxElementsInMemory="10" eternal="true" overflowToDisk="false" />  

 </ehcache>

Here it’s clear that we have created a cache with name Customer, I will use this Cache to store Customer details

Next step is to use it in your code. In my example I created a simple Spring based application where we have Customer Controller which is used to retrieve Customer Information

We have Customer Object with Customer Id, name and address details and related setter getter methods

public class Customer {
      public String address;
      public String name;
      public String id;

Next step is to create Controller. Customer Controller is very simple. I am using Spring Restful Web services to retrieve Customer Information. In my Controller I have no logic related to EhCache. I just have two versions of getCustomer method (one with Annotation and one without Annotation), save Customer and Clear Cache method. Code is simple and self explanatory for any Spring MVC developer.

package com.eiconsulting.web;

import net.sf.ehcache.CacheManager;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;

import com.eiconsulting.beans.Customer;
import com.eiconsulting.services.CustomerService;

@Controller
public class CustomerController {
	@Autowired @Qualifier("CustomerService")
	public CustomerService customerService;

	
	
	@RequestMapping(value="/GetCustomer/{customerId}",method={RequestMethod.GET})
	@ResponseStatus(HttpStatus.OK)
	public @ResponseBody String getCustomer(@PathVariable String customerId){
		Customer c=customerService.getCustomer(customerId);
		return c.toString();
	}
	
	
	@RequestMapping(value="/GetCachedCustomer/{customerId}",method={RequestMethod.GET})
	@ResponseStatus(HttpStatus.OK)
	public @ResponseBody String getCachedCustomer(@PathVariable String customerId){
		Customer c=customerService.getCachedCustomer(customerId);
		return c.toString();
	}
	
	@RequestMapping(value="/ClearCache",method={RequestMethod.GET})
	@ResponseStatus(HttpStatus.OK)
	public @ResponseBody String clearCache(){
		boolean result=customerService.clearCache();
		if(result) return "Sucessfully Cache Cleaned";
		else return "Not able to Clean Cache";
			
	}
	
	@RequestMapping(value="/SaveCustomer/{customerId}",method={RequestMethod.GET})
	@ResponseStatus(HttpStatus.OK)
	public @ResponseBody String saveCustomer(@PathVariable String customerId){
		
		Customer c=new Customer();
		c.setId(customerId);
		c.setAddress("New Address");
		c.setName("New Name");
		boolean result=customerService.saveCustomer(c);
		if(result) return "Sucessfully Saved Customer";
		else return "Not able to Save Customer";
			
	}
	
}

If you notice Controller is calling Customer Service. Customer Service is our main class and it’s used to get Customer Information. It can get information from Database using Hibernate or from any backend. Here I just provided basic implementation. Idea is to understand usage of EhCache

Following Service methods are used to retrieve and store information in Cache

	@Autowired
	public CacheManager cacheManager;
	
	public boolean saveCustomer(Customer customer){
		Cache cache=cacheManager.getCache("customer");
		cache.put(new Element(customer.getId(),customer));
		return true;
	}
	
	public Customer getCachedCustomer(String customerId){
		Cache cache=cacheManager.getCache("customer");
		return (Customer)cache.get(customerId).getObjectValue();	
	}

Previously we have defined “cacheManager” object in our Spring.xml file and also we have defined a Cache with name “customer” in ehcache.xml file. Its time to use both these configurations

getCache method is use to retrieve Cache Object and we are storing new Element in this cache. Element requires key, value pair so I am using id filed as a key. Later on we can use same key to retrieve Customer Object from Cache.

Another great way of using EhCache is Spring Annotation

@Cacheable(cacheName="customer")
	public Customer getCustomer(String customerId){
		Customer c=new Customer();
		c.setId(customerId);
		c.setName("Adeel Shafqat");
		c.setAddress("Address");
		return c;
	}

Add Cacheable Annotation to methods you would like to cache. In our case we are using it for getCustomer method. If we call getCustomer method with customerId 1, first time complete method will be called. If we will call this method again with same customerId then response will be returned from Cache.

To Clear Cache we can just use TriggerRemove Annotation

@TriggersRemove(cacheName = "customer", when = When.AFTER_METHOD_INVOCATION, removeAll = true) 
	public boolean clearCache(){
		return true;
	}

Complete Source Code is present at following location

https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0B0YFdqXJcI3mY2ZiYzA4NWQtNmQ0ZS00ZWM0LTlkMzktMmM3YmJmZjUzNDEy&hl=en_US

Integration with Hibernate as a Second Level Cache

Hibernate uses different type of Caches

· The first cache type is the session cache. The session cache caches object within the current session.

· The second cache type is the query Cache. The query cache is responsible for caching queries and their results.

· The third cache type is the second level cache. The second level cache is responsible for caching objects across sessions.

EhCache is used as second level cache. EhCache integration with Hibernate is quite simple as well. You just need to define some properties in persistence.xml file.

EhCache jars are available via maven, simply add the following dependency to your pom.xml

 <dependency>
   <groupId>net.sf.ehcache</groupId>
   <artifactId>ehcache-core</artifactId>
   <version>2.4.5</version>
</dependency>

Next step is to perform changes in persistence.xml

<property name="hibernate.cache.region.factory_class" value="net.sf.ehcache.hibernate.EhCacheRegionFactory"/>
<property name="hibernate.cache.use_query_cache" value="true"/>
<property name="hibernate.cache.use_second_level_cache" value="true"/>
<property name="hibernate.cache.provider_class" value="net.sf.ehcache.hibernate.EhCacheProvider" /> 
<property name="hibernate.cache.provider_configuration_file_resource_path" value="ehcache.xml" />

Put ehcache.xml at your classpath. It could be in classes or WEB-INF folder

<?xml version="1.0" encoding="UTF-8"?> 
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">    
 
  	<defaultCache eternal="true" maxElementsInMemory="100" overflowToDisk="false" />     	
  	<cache name="messages" maxElementsInMemory="10" eternal="true" overflowToDisk="false" />  

 </ehcache>

In you Entity just add Annotations related to ehcache and thats it.

@Entity
@Table(name="MESSAGES")
@Cache(region = "messages", usage = CacheConcurrencyStrategy.READ_WRITE)

public class Message {

Complete Source Code is present at following location

https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0B0YFdqXJcI3mMDJiMDU4MmUtZWFkYy00MTAxLWFjMmYtMWYyMGNhMWY2Mjdj&hl=en_US

Spring ROO, An Amazing Framework

2011-09-29T08:47:00.000-07:00

Recently I got an assignment to build a new web based server side project. Normally for Web based projects we used Spring MVC, Hibernate for persistence and Maven for dependencies management. At this point I have two options.

First option is to manually create a new Project, create Maven POM file, create folder structure, define dependencies related to spring and Hibernate, create Hibernate and Spring configuration files like persistence.xml and web.xml. Usually this process takes two to three hours to configure every thing properly and make this project in running condition

Second Option is to use “Spring Roo”. Spring Roo will work as my junior developer. It will automatically generate Application Structure, pom file, required configuration files for spring and hibernate and all this process will take maximum 5 to 10 minutes and for this I just have to execute few commands.

Is it real or I am in my dreams J

Spring Roo is a dynamic, domain-driven development framework from SpringSource the makers of the Spring framework. Spring Roo uses standard Java and Spring, but during development time, the Spring Roo shell watches you work, helping out as possible and required. Think of Spring Roo as being the ultimate pair-programming buddy, or the most advanced code completion you’ve ever seen

As an example of this power, suppose you’re in the middle of editing a JPA entity in a Spring Roo project, and adding a field of interest—perhaps a name field to a Customer entity. As soon as you’ve finished typing out the field definition, Spring Roo automatically jumps in and adds a corresponding accessor and mutator pair for that field to a shadow class definition in the background. Similarly, it will implement a toString() definition (reflecting the fields added) if one does not already exist, and it will implement an equals() method following the same criteria.. If you update the field, the accessor and mutator are updated as well as the equals and toString methods. If you add an equals method to the JPA entity, the shadow definition is removed, delegating to your implementation instead. So, this shadow class definition is kept in sync, responding to your changes, but it does not get in your way. It defers to your will in all cases.

So, you get Java, but you don’t have to pay the cost of writing all that Java.

The Tooling

Latest Spring Roo Release can be downloaded from http://www.springsource.org/download

Once downloading will finish you will find a folder spring-roo-1.2.0.M1. If you go to bin folder you will find roo.bat. Once you click on this file a command console will open and from here you can control your project.

Another simpler option is to use Spring Source Tool Suit IDE which has built-in support of Spring Roo and you don’t have to worry about any configuration. This ID is freely available at Spring Source website

http://www.springsource.com/downloads/sts

It’s an Eclipse based IDE Just download this IDE and start your development

New Project

To start a new Project just click on FileàNewàSpring Roo Project

Enter name of the project. In my case I named it “CustomerManagementSystem”. Define top level java package which in my case is “com.eiconsulting.cms” and press finish.

This will automatically generate a project with Correct Maven based application structure, pom.xml file with correct dependencies of JUnit, the correct and latest versions of spring, AspectJ, logging, and the latest servlet APIs.

You will notice a Roo.shell at bottom of your ide

This shell is your pair programmer. Here you will write all your commands

So let’s start the magic of Roo

In our project we are planning to use JPA and for this Hibernate as a JPA provider and My SQL as a database. Our pair programmer will help us to configure all this we just need to execute a simple command at Roo console

Actually I am not good in remembering commands, I remember it was some thing like “persist” so I just type persis and press CTRL+ SPACE, automatically “persistence setup” appears in my console after that I press CTRL+ SPACE again now I have two options to define provider and database. Finally I configured my command like this

persistence setup --provider HIBERNATE --database MYSQL

I pressed enter and Magic started

Roo has defined all Hibernate related dependencies in my POM. In META-INF folder persistence.xml automatically created with all MySQL related configuration details and now in a newly generated database.properties file I just have to define database url, username and password.

Now my My Project has full support of Spring and Hibernate with all required configuration files.

After this step my IDE started complaining about Maven Dependency

Missing artifact org.springframework.roo:org.springframework.roo.annotations:jar:1.1.4.RELEASE:provided

I searched about this at Internet and come up with a very simple solution

Open you pom file and replace Roo dependency

<groupId>org.springframework.roo</groupId>

<artifactId>org.springframework.roo.annotations</artifactId>

<version>${roo.version}</version>

<scope>provided</scope>

</dependency>

With this

<groupId>org.springframework.roo</groupId>

<artifactId>org.springframework.roo.annotations</artifactId>

<version>1.0.2.RELEASE</version>

<scope>compile</scope>

</dependency>

Problem solved

Next step is to write my business logic. My initial thinking, “defiantly I have to write all my code by my self “, Luckily Spring Roo is helping me here as well

Because I am developing a CMS so my business requirement is to create a Customer Entity which has name and address field. To create an entity in Spring ROO simply type

entity --class com.eiconsulting.beans.Customer

In response ROO will automatically generate package and class with name Customer. Also you have noticed that ROO has created couple of configuration files for this entity. These files are not part of our project and they are ROO internal use and we don’t have to bother about them.

Next step, we want to add name and address field. Following commands will perform this action

field string --fieldName name –notNull

field string --fieldName address --notNull

You will notice that ROO has generated few annotation is Customer class

@RooJavaBean

@RooToString

@RooEntity

This is for ROO Internal use to assist you during development If you simply don’t want Roo to even bother, simply remove the annotation from the Customer.java file and watch as Spring Roo removes the corresponding .aj file. If, later, you decide you that you were a bit hasty in dismissing its help, simply replace the annotation and Roo will obediently hop back into action again.

From this point you can move forward and start writing your business logic as per our requirements

As I mentioned earlier that we are planning to build MVC based project and we noticed that our project doesn’t contains folder structure for a Web based project, also for MVC based project we need a Customer Controller

Well very simple just execute following command and see the magic

controller scaffold --entity com.eiconsulting.beans.Customer --class com.eiconsulting.web.CustomerController

Automatically ROO will convert you project to a Web based project with Customer Controller with proper directory structure for a web based project

Also you will notice that ROO has create lots of images, css files and sample images

All these files are for your support. You can delete them or use them as per your requirements

Just build your project using your maven package command and it will generate a resultant war file. In our case it is CustomerManagementSystem-0.1.0.BUILD-SNAPSHOT.war. Deploy it in your favourite web server

You will notice a file with name log.roo. This file contains all commands which you have executed in ROO so far

To remove Roo from a project, you need to import the project into Eclipse or SpringSource Tool Suite. Once the project has been imported into Eclipse, right-click the project name in Package Explorer and select Refactor > Push-In Refactor. If this option is missing, ensure that you have a recent version of AJDT installed. After selecting the push-in refactor menu option, a list of all Roo inter-type declarations will be displayed. Simply click OK. AJDT will have now moved all of the Roo inter-type declarations into your standard .java files. The old *_Roo_*.aj files will have automatically been deleted. Complete Removal details are present at this URL http://static.springsource.org/spring-roo/reference/html/removing.html

Reference: Getting Started with ROO

Restful WebServices using Spring

2011-09-28T04:41:00.000-07:00

In recent years, Representational State Transfer (REST) has emerged as a popular information-centric alternative to traditional SOAP-based web services. In Spring, REST support builds upon Spring MVC

The fundamentals of REST

Representational: REST resources can be represented in virtually any form, including XML, JavaScript Object Notation (JSON), or even HTML—whatever form best suits the consumer of those resources

State: when working with REST, we’re more concerned with the state of a resource than with the actions we can take against resources.

Transfer: REST involves transferring resource data, in some representational form, from one application to another.

REST is about transferring the state of resources—in whatever form is most appropriate from a server to a client (or vice versa).

Spring supports development of REST resources in the following ways:

Controllers can handle requests for all HTTP methods, including the four primary REST methods: GET, PUT, DELETE, and POST.
The new @PathVariable annotation enables controllers to handle requests for parameterized URLs (URLs that have variable input as part of their path).
The <form:form> JSP tag from Spring’s form-binding JSP tag library, along with the new HiddenHttpMethodFilter, make it possible to submit PUT and DELETE requests from HTML forms, even in browsers that don’t support those HTTP methods.
Resources can be represented in a variety of ways using Spring’s view and view resolvers, including new view implementations for rendering model data as XML, JSON, Atom, and RSS.
The representation best suited for the client can be chosen using the new ContentNegotiatingViewResolver
View-based rendering can be bypassed altogether using the new @ResponseBody annotation and various HttpMethodConverter implementations.
Similarly, the new @RequestBody annotation, along with HttpMethodConverter implementations, can convert inbound HTTP data into Java objects passed into a controller’s handler methods.

Spring MVC’s model for writing controller classes is extremely flexible. Almost any method with almost any signature can be annotated to handle a web request. But a side effect of such flexibility is that Spring MVC allows you to develop controllers that aren’t ideal in terms of RESTful resources. It’s too easy to write RESTless controllers.

Example of Spring MVC (Restless controller)

@Controller

@RequestMapping("/displaySpittle.htm")

public class DisplaySpittleController {

private final SpitterService spitterService;

@Inject

public DisplaySpittleController(SpitterService spitterService)

{

this.spitterService = spitterService;

}

@RequestMapping(method=RequestMethod.GET)

public String showSpittle(@RequestParam("id") long id, Model model)

{

model.addAttribute(spitterService.getSpittleById(id));

return "spittles/view";

}

Take note of the @RequestMapping annotation at the class level. It says that this controller will handle requests for /displaySpittle.htm. That seems to imply that this controller is focused on the specific use case of displaying spittles (which is corroborated by the name of the class).

Nothing is terribly wrong with how DisplaySpittleController is written. But it isn’t a RESTful controller. It’s action-oriented and focused on a specific use case: displaying a Spittle object’s details in HTML form. Even the controller’s class name agrees.

Handling RESTful URLs URLs are one of the first things that most people think about when starting to work with REST.

http://localhost:8080/Spitter/displaySpittle.htm?id=123

is an example of Restless URL. This URL doesn’t locate or identify a resource. It demands that the server display a Spittle. The only part of the URL that identifies anything is the id query parameter. The base portion of the URL is verb-oriented. That is to say that it’s a RESTless URL

http://localhost:8080/Spitter/spittles/123

is an example of Restful URL. One thing that’s not clear about this URL is what it does. That’s because the URL doesn’t do any-thing. Rather, it identifies a resource. Instead of using a query parameter to identify the resource, the entire base URL identifies the resource. In fact, the new URL has no query parameters at all

To enable parameterized URL paths, Spring 3 introduced a new @PathVariable anno-tation. To see how this works, look at SpittleController, a new Spring MVC control- ler that takes a resource-oriented approach to handling requests for Spittles.

@Controller

@RequestMapping("/spittles")

public class SpittleController

{

private SpitterService spitterService;

@Inject

public SpittleController(SpitterService spitterService)

{

this.spitterService = spitterService;

}

@RequestMapping(value="/{id}", method=RequestMethod.GET)

public String getSpittle(@PathVariable("id") long id, Model model)

{

model.addAttribute(spitterService.getSpittleById(id));

return "spittles/view";

}

You’re probably wondering about those weird curly-braces in the URL pattern. The part that says {id} is a placeholder through which variable data will be pass into the method. It corresponds to the @PathVariable annotation on the id method parameter.

Restful Code Example

Following is Code for a Customer Controller. In this Code I tried to implement all CUID methods for Customer Object

package com.playground.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.http.HttpStatus;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.web.bind.annotation.ResponseStatus;

import com.playground.entity.Customer;

import com.playground.services.CustomerService;

@Controller

public class CustomerController {

@Autowired @Qualifier("CustomerService")

CustomerService service;

@RequestMapping(value= "/findcustomer/{customerId}/",method={RequestMethod.GET})

@ResponseStatus(HttpStatus.OK)

public @ResponseBody String findCustomer(@PathVariable String customerId){

Customer c=service.findCustomer(customerId);

return "Here is Customer:"+c.getName();

}

@RequestMapping(value= "/savecustomers",method={RequestMethod.POST})

@ResponseStatus(HttpStatus.CREATED)

public @ResponseBody String saveCustomer(@RequestParam(value="name") String name, @RequestParam(value="address", required=false) String address, @RequestParam(value="telephone") String telephone){

Customer c=new Customer();

c.setName(name);

c.setAddress(address);

c.setTelephone(telephone);

boolean result=service.saveCustomer(c);

if(result)

return "Save Operation Completed Sucessfully";

else

return "Save Operation is not Sucessfull";

}

@RequestMapping(value= "/updatecustomers/{customerId}/{name}/{address}/{telephone}",method={RequestMethod.PUT})

@ResponseStatus(HttpStatus.ACCEPTED)

public @ResponseBody String updateCustomerDetails(@PathVariable String customerId,@PathVariable String name, @PathVariable String address, @PathVariable String telephone){

System.out.println("Here is the Customer Details:"+customerId+":"+name+":"+address+":"+telephone);

Customer c=new Customer();

c.setCustomerId(customerId);

c.setName(name);

c.setAddress(address);

c.setTelephone(telephone);

boolean result=service.updateCustomerDetails(c);

if(result)

return "Update Operation Completed Sucessfully";

else

return "Update Operation is not Sucessfull";

}

@RequestMapping(value= "/deletecustomers/{customerId}",method={RequestMethod.DELETE})

@ResponseStatus(HttpStatus.ACCEPTED)

public @ResponseBody String deleteCustomer(@PathVariable String customerId){

System.out.println("Here is the Customer Id:"+customerId);

boolean result=service.deleteCustomer(customerId);

if(result)

return "Delete Operation Completed Sucessfully";

else

return "Delete Operation is not Sucessfull";

}

@RequestMapping(value= "/allcustomers/",method={RequestMethod.GET})

@ResponseStatus(HttpStatus.OK)

public @ResponseBody String getAllCustomers(){

List result=service.getAllCustomers();

return "Here is the list";

}

URL for Find Customer

http://localhost:8090/RestfulPlayGround/findcustomer/1/

URL to Get All Customers

http://localhost:8090/RestfulPlayGround/allcustomers/

For Save Customer I have created a HTML form

Normal browsers doesn’t support PUT and DELETE HTTP method so I have created AJAX form to perform update and delete Operations

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Test Restful PlayGround</title>

$(document).ready(function() {

//if submit button is clicked

$('#submit').click(function () {

var customerId= $('input[name=customerId]');

//start the ajax

$.ajax({

//this is the php file that processes the data and send mail

url: "/RestfulPlayGround/deletecustomers/"+customerId.val(),

type: "DELETE",

success: function (html) {

alert(html);

}

});

return false;

});

$('#update').click(function () {

//Get the data from all the fields

var customerId= $('input[name=customerId]');

var name= $('input[name=name]');

var address= $('input[name=address]');

var telephone= $('input[name=telephone]');

//start the ajax

$.ajax({

//this is the php file that processes the data and send mail

url: "/RestfulPlayGround/updatecustomers/"+customerId.val()+"/"+name.val()+"/"+address.val()+"/"+telephone.val(),

type: "PUT",

success: function (html) {

alert(html);

}

});

return false;

});

</script>

</head>

<body>

<br>

Delete Customer

<br>

Customer Id:<input type="text" name="customerId"><br>

</form>

<br>

Update Customer

<br>

Customer Id:<input type="text" name="customerId"><br>

Name:<input type="text" name="name"><br>

Address:<input type="text" name="address"><br>

Telephone:<input type="text" name="telephone"><br>

</form>

<br>

Save Customer

<br>

Name:<input type="text" name="name"><br>

Address:<input type="text" name="address"><br>

Telephone:<input type="text" name="telephone"><br>

</form>

</body>

</html>

Complete Application Source Code is Present at following location

https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0B0YFdqXJcI3mYzM5ZDg0OTQtOTI1MS00YjBiLThhNjQtMTU1MTFmOWRlYjc2&hl=en

Reference: Spring in Action 3

Hibernate(JPA), Spring MVC and JBoss 6

2011-09-26T02:48:00.000-07:00

After spending many hours finally i am able to configure Spring with Hibernate in JBoss Server.

For this application I have used Spring 3.5, Hibernate 3.5.1 and JBoss 5 and 6.

Following are some important configuration file required for this Integration

Here is link for application Source Code

https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0B0YFdqXJcI3mMTgxZDc2OGItMjM4NS00NTA5LWJjMzQtNTUzNTc4ZGNmMGFm&hl=en_US

web.xml
No Speciall Configuration is required in web.xml. Here is how i configiured Controller Servler

  <servlet>
        <servlet-name>Spring MVC</servlet-name>
           <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
        <servlet-name>Spring MVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

persistance.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
  <persistence-unit name="helloworld" transaction-type="JTA">
    <provider>org.hibernate.ejb.HibernatePersistence</provider>
    <jta-data-source>java:/OracleDS</jta-data-source>
     <class>com.playground.beans.Message</class>

    <properties>
      <property name="hibernate.transaction.manager_lookup_class" value="org.hibernate.transaction.JBossTransactionManagerLookup"/>
      <property name="hibernate.dialect" value="org.hibernate.dialect.Oracle9Dialect"/>
      <property name="hibernate.hbm2ddl.auto" value="update"/>
       <property name="hibernate.show_sql" value="true"/>
     <!-- Print sql executed - useful for debugging -->
      <property name="hibernate.show_sql" value="true"/>
      <property name="hibernate.format_sql" value="true"/>
    <!-- Auto-detect entity classes -->
       <property name="hibernate.archive.autodetection" value="class, hbm"/>

    </properties>
  </persistence-unit>
  </persistence>

spring.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:mvc="http://www.springframework.org/schema/mvc" 
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/mvc 
 http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 
 http://www.springframework.org/schema/tx
 http://www.springframework.org/schema/tx/spring-tx.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.0.xsd 
 http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/aop
 http://www.springframework.org/schema/aop/spring-aop.xsd">

       <mvc:resources mapping="/resources/**" location="/resources/"/>
          <mvc:annotation-driven/>
          
         <context:component-scan base-package="com.playground"/>
         
         <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/views/"/>
            <property name="suffix" value=".jsp"/>
        </bean>

        <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">    
            <property name="persistenceUnitName" value="helloworld" />
         </bean>
    
     <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
          <property name="transactionManagerName" value="java:/TransactionManager" />
          <property name="userTransactionName" value="UserTransaction" />
     </bean>


     <!-- Use Spring AOP capabilities to manage transactions -->
    <aop:config>
      <aop:pointcut id="accountTransactions" 
               expression="execution(* com.playground.services.ProcessMessage.*(..))"/>
      <aop:advisor pointcut-ref="accountTransactions" advice-ref="txAdvice" />
    </aop:config>

        <tx:advice id="txAdvice" transaction-manager="transactionManager">
          <tx:attributes>
            <tx:method name="processMessage" propagation="REQUIRED"/>
            <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
          </tx:attributes>
        </tx:advice>
 </beans>

DAO File

package com.playground.dao;

import javax.persistence.EntityManager;

import javax.persistence.EntityManagerFactory;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.playground.beans.Message;
@Component("MessageDAO")
public class MessageDAO {
    
   @Autowired
   EntityManagerFactory entityManagerFactory;
    public String processMessage(Message message){
                EntityManager manager=entityManagerFactory.createEntityManager();
                System.out.println("Here I reached in Last Point:"+message.getMessageText());
                manager.persist(message);
                return "Sucess";
    }
    }

Maven POM File

I used maven for war file creation and dependencies resolution. Following is my POM file. Most important point we need to take care is that your war file should not contains Hinernate jar files becuase this will make conflict with JBoss Hibernate libraries

Following is my POM file

<project 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</modelVersion>
    <groupId>PlayGround</groupId>
    <artifactId>PlayGround</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>PlayGround</name>
    <url>http://maven.apache.org</url>
    <dependencyManagement>
        <dependencies>
        </dependencies>
    </dependencyManagement>
    <properties>
        <springframework>3.0.5.RELEASE</springframework>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${springframework}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${springframework}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${springframework}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${springframework}</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>3.0.5.RELEASE</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${springframework}</version>
            <exclusions>
                <!-- Exclude Commons Logging in favor of SLF4j -->
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${springframework}</version>
            <exclusions>
                <!-- Exclude Commons Logging in favor of SLF4j -->
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        
        <!-- logging -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>1.6.1</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.1</version>
            <scope>runtime</scope>
        </dependency>


        <!-- Hibernate Stuff -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-annotations</artifactId>
            <version>3.5.1-Final</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-commons-annotations</artifactId>
            <version>3.2.0.Final</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>3.5.1-Final</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>3.5.1-Final</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>4.1.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate.javax.persistence</groupId>
            <artifactId>hibernate-jpa-2.0-api</artifactId>
            <version>1.0.0.Final</version>
            <scope>provided</scope>
        </dependency>


    <!-- Required only for Release in Jboss if we Exclude Hibernate becuase of conflict with JBoss -->
    
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.6</version>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2</version>
        </dependency>
        
            <dependency>
                <groupId>commons-collections</groupId>
                <artifactId>commons-collections</artifactId>
                <version>3.1</version>
            </dependency>
        
        
            <dependency>
                <groupId>dom4j</groupId>
                <artifactId>dom4j</artifactId>
                <version>1.6.1</version>
            </dependency>
        
            <dependency>
                <groupId>asm</groupId>
                <artifactId>asm</artifactId>
                <version>3.1</version>
            </dependency>
        
            <dependency>
                <groupId>antlr</groupId>
                <artifactId>antlr</artifactId>
                <version>2.7.6</version>
            </dependency>

            <dependency>
                    <groupId>xml-apis</groupId>
                    <artifactId>xml-apis</artifactId>
                    <version>1.0.b2</version>
                    <scope>provided</scope>
            </dependency>
    
    
            <dependency>
                <groupId>javax.validation</groupId>
                <artifactId>validation-api</artifactId>
                <version>1.0.0.GA</version>
                <scope>provided</scope>
            </dependency>
           
        </dependencies>
    <build>
        <finalName>PlayGround</finalName>
        <defaultGoal>package</defaultGoal>

      <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>

        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-site-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <locales>en</locales>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Hibernate "Hello World" with and without Annotation

2011-09-20T05:47:00.000-07:00

Without Annotation
1.   Entity should be a normal POJO class and there is no need to implement Persistance Interface
2.   There should be a mapping.xml file for each Entity, Standard for name is Entity.hbm.xml
3.   Main tag in hbm.xml file is <hibernate-mapping>
4.   You can define multiple table mappings in a single file like
<class name="com.persistance.beans.Message" table="MESSAGES">
5.   For Primary key column tag should be like this

<id name="id" column="MESSAGE_ID">
<generator />
</id>

6. For other properties tags should be
<property name="message" column="MESSAGE_TEXT" />
7. If there is a foreign key we can define it like

<many-to-one name="nextMessage" cascade="all" column="NEXT_MESSAGE_ID"
foreign-key="FK_NEXT_MESSAGE" />

8.   Name of Configuration file is normally hibernate.cfg.xml or hibernate.properties
9.   In hibernate.cfg.xml we define
<hibernate-configuration>
10.   <mapping resource="Message.hbm.xml" /> is used to define details of mapping file
11.   Main class code shoud look some thing like this

SessionFactory sessionFactory=new Configuration().configure().buildSessionFactory();
Session session  = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
Message message = new Message("Hello World");
Long msgId = (Long) session.save(message);
tx.commit();
session.close();
sessionFactory.close();

Using Annotation
1. If we are using Annotation then we need to Annotate class with proper Annotation

@Entity
@Table(name="MESSAGES")

2. For Primary Key Annotation should be like

@Id @GeneratedValue
@Column(name = "MESSAGE_ID")

3. For Column
@Column(name = "MESSAGE_TEXT")
4. For Foreign key

@ManyToOne(cascade = CascadeType.ALL)
@JoinColumn(name = "NEXT_MESSAGE_ID")

5.   If we are using Annotation then we have to put persistance.xml file under META-INF directory
6.   There is no need of .hbm.xml file for every entity
7.   hibernate.cfg.xml file is also not required as Hibernate can automatically detect classes with annotation
8.   In persistance.xml we need to define properties related to connection pool

<persistence-unit name="persistanceworld">
<properties>
</properties>
</persistence-unit>

9. In Main class code should look some thing like this

EntityManagerFactory emf = Persistence.createEntityManagerFactory("persistanceworld");
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
AnnotationMessage message = new AnnotationMessage("Hello World");
em.persist(message);
tx.commit();
em.close();

Why and how to use Mockito

2011-09-14T08:04:00.000-07:00

Mockito is an open source testing framework for Java. This framework allows creation of “Mock Objects” during Unit testing for the purpose of Test Driven Development. It helps you to create Mock Objects and define behaviour of these objects so you can use them as per your requirement in your test cases

Main Website for Mockito
http://code.google.com/p/mockito/
Mockito Example
To run Mockito example you should have mockito jar in your project class path. In my example I am using Maven to build project
http://code.google.com/p/mockito/downloads/list
Sample Class Source Code

import static org.junit.Assert.assertEquals;import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.junit.Test;

public class MockitoTestCases {

 @Test
 public void example1() {

  /*
   * A Simple Example where you we have used VERIFY. Test Result will be
   * successful if we verify with 1 Else test result will be failure
   */
  List mockedList = mock(List.class);
  mockedList.add("1");
  // This will make test result successful
  verify(mockedList).add("1");
  // This will make test result failure
  // verify(mockedList).add("2");

  mockedList.get(10);
  verify(mockedList).get(10);
  // This will make test fail
  // verify(mockedList).get(101);

  // Here we are mocking an Iterator
  Iterator ii = mock(Iterator.class);
  ii.next();
  verify(ii).next();
  // This will make test result failure because notify method is not
  // called for this object
  // verify(ii).notify();

  // Verify Times
  List mockedList1 = mock(List.class);
  mockedList1.add("1");
  mockedList1.add("1");

  verify(mockedList1, times(2)).add("1");
  // This will make result failure becuase add is only called 2 times
  // verify(mockedList1, times(3)).add("1");

  // Here We are mocking an Object behaviour by specifying WHEN clause
  ArrayList<String> mockedList2 = mock(ArrayList.class);
  mockedList2.add("one");

  when(mockedList2.get(0)).thenReturn("first");
  System.out.println(mockedList2.get(0));

  when(mockedList2.add("1")).thenReturn(true);
  System.out.println(mockedList2.add("1"));

  when(mockedList2.add("1")).thenReturn(false);
  System.out.println(mockedList2.add("1"));

  System.out.println(mockedList2.size()); // return 0
  when(mockedList2.size()).thenReturn(100);
  System.out.println(mockedList2.size());// return 100

  /*
   * Create a ArrayList using Mockito. If some one will inquire 99th
   * element it will return results else it will return null value
   */

  ArrayList<String> mockObject = mock(ArrayList.class);
  when(mockObject.get(99)).thenReturn("I am 99th Object");

  System.out.println(mockObject.get(0)); // return null
  System.out.println(mockObject.get(99)); // return I am 99th Object

  System.out.println(mockObject.size()); // return 0
  when(mockObject.size()).thenReturn(10);
  System.out.println(mockObject.size()); // return 10
  for (int i = 0; i < mockObject.size(); i++) {
   System.out.println("I am priting i:" + i);
  }
  // but if you write mockObject.get(i) it will return null

  for (int i = 0; i < mockObject.size(); i++) {
   System.out.println("I am priting mockObject.get(i):"
     + mockObject.get(i));
  }

  // Here we are mocking an Iterator
  Iterator i = mock(Iterator.class);
  when(i.next()).thenReturn("Hello").thenReturn("World");
  String result = i.next() + " " + i.next();
  // This makes test successful
  assertEquals("Hello World", result);
 // This makes test fail
  // assertEquals("Hello World1", result);
}
}

Maven Dependencies for Mockito and JUnit

<dependency>
  <groupId>org.mockito</groupId>
  <artifactId>mockito-core</artifactId>
  <version>1.9.0-rc1</version>
  <scope>test</scope>
</dependency>

<!—Or if you needs extra dependencies: objenesis & hamcrest -->

<dependency>
    <groupid>org.mockito</groupid>
    <artifactid>mockito-all</artifactid>
    <version>1.8.5</version>
    <scope>test</scope>
</dependency>

Maven POM.XML

<project 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</modelVersion>
  <groupId>MockitoTest</groupId>
  <artifactId>MockitoTest</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>MockitoTest</name>
  <url>http://maven.apache.org</url>
<dependencies>
  <dependency>
   <groupId>org.mockito</groupId>
      <artifactId>mockito-core</artifactId>
      <version>1.8.5</version>
      <scope>test</scope>
  </dependency>
 <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.8.2</version>
   <scope>test</scope>
  </dependency>
</dependencies>
<build>
  <finalName>MockitoTest</finalName>
  <testSourceDirectory>src</testSourceDirectory>
  <testResources>
   <testResource>
    <directory>src</directory>
   </testResource>
  </testResources>
 <plugins>
   <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.1</version>
    <configuration>
     <source>1.6</source>
     <target>1.6</target>
    </configuration>
   </plugin>
   <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-site-plugin</artifactId>
    <version>2.3</version>
    <configuration>
     <locales>en</locales>
    </configuration>
   </plugin>
   </plugins>
 </build>
</project>

Maven for Web based Projects

2011-09-14T02:42:00.000-07:00

Maven is a software tool for project management and builds automation.

Maven serves a similar purpose to the Apache Ant tool, but it is based on different concepts and works in a profoundly different manner. Maven is hosted by the Apache Software Foundation, where it was formerly part of the Jakarta Project.

Maven uses a construct known as a Project Object Model (POM) to describe the software project being built, its dependencies on other external modules and components, and the build order. It comes with pre-defined targets for performing certain well-defined tasks such as compilation of code and its packaging.

Maven dynamically downloads Java libraries and Maven plug-ins from one or more repositories. Maven provides built-in support for retrieving files from the Maven 2 Central Repository and other Maven repositories, and can upload artefacts to specific repositories after a successful build. A local cache of downloaded artefacts acts as the primary means of synchronizing the output of projects on a local system.

To Use Maven for a web based project application should follow Maven Recommended directory structure and it should have a pom file which contains project properties and dependency details

To convert your simple Web based project to a Maven project using Eclipse follow following steps

Configure Maven installation at your machine
In Document and Settings Users folder create a folder with name .m2 and in this folder create a file with name settings.xml

C:\Documents and Settings\38569Ad\.m2\settings.xml

This file contains configuration details and server URL related to Maven repository
Create New Dynamic Web Project
Give you project a name, for example I named it SpringMvnPro
Make a new folder with name src
Inside src create two separate folder with name main and test
Main folder is used to store project source and resources
Test folder is used to store test cases and test resources
Inside main create new folders with name java and resources
If you test cases for your project then inside test create new folders with name java and resources
Java folder is used to store src files
resources folder is used to store web.xml file and if you are using spring then its used to store spring related xml files
Next very important step is to create pom.xml file. In POM file we mention important dependency and plug-in details.
Store pom.xml at root of your project folder
For example in our project we are using Spring so we need to add spring dependencies

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

<version>${springframework}</version>

</dependency>

Add Spring MVC dependencies

<groupId>org.springframework</groupId>

<artifactId>spring-web</artifactId>

<version>${springframework}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-webmvc</artifactId>

<version>${springframework}</version>

</dependency>

Right Click on Project Properties and Java Build path. Source folder should be SpringMvnPro/src/main/java and ourput folder should be SpringMvnPro/target/classes
Righlt Click on Project à Select Maven à and enable dependency Management
To make war file right click on pom.xml, select run as, Click on Run Configuration. Click on Maven Build. Create new Configuration. Select Project and In Goals add clean package. Run Configuration
This will generate war file with name SpringMvnPro.war

Maven Repository

http://mvnrepository.com/

Application Structure

Content of pom.xml file

<project 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">

<groupId>SpringMvnPro</groupId>

<artifactId>SpringMvnPro</artifactId>

<version>0.0.1-SNAPSHOT</version>

<name>SpringMvnPro</name>

<url>http://maven.apache.org</url>

<springframework>3.0.5.RELEASE</springframework>

</properties>

<groupId>javax.inject</groupId>

<artifactId>javax.inject</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

<version>${springframework}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-web</artifactId>

<version>${springframework}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-webmvc</artifactId>

<version>${springframework}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>${springframework}</version>

</dependency>

</dependencies>

<build>

<finalName>SpringMvnPro</finalName>

<defaultGoal>package</defaultGoal>

<directory>src/test/resources</directory>

</testResource>

</testResources>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-compiler-plugin</artifactId>

</configuration>

</plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-site-plugin</artifactId>

</configuration>

</plugin>

</plugins>

</build>

</project

Web Application Development using Spring MVC

2011-09-12T02:53:00.000-07:00

Spring MVC helps you to build web based applications that are as flexible and as loosely coupled as the Spring Framework itself.

Spring MVC Life Cycle

When the request leaves the browser, it carries information about what the user is asking for. At least, the request will be carrying the requested URL. But it may also carry additional data such as the information submitted in a form by the user.

The first stop in the request’s travels is at Spring’s DispatcherServlet. Like most Java-based web frameworks, Spring MVC funnels requests through a single front con-troller servlet. A front controller is a common web application pattern where a single servlet delegates responsibility for a request to other components of an application to perform actual processing. In the case of Spring MVC, DispatcherServlet is the front controller.

The DispatcherServlet’s job is to send the request on to a Spring MVC controller. A controller is a Spring component that processes the request. But a typical applica-tion may have several controllers and DispatcherServlet needs some help deciding which controller to send the request to. So the DispatcherServlet consults one or more handler mappings to figure out where the request’s next stop will be. The handler mapping will pay particular attention to the URL carried by the request when making its decision.

Once an appropriate controller has been chosen, DispatcherServlet sends the request on its chosen controller. At the controller, the request will drop off its payload (the information submitted by the user) and patiently wait while the controller processes that information. (Actually, a well-designed controller per forms little or no processing itself and instead delegates responsibility for the business logic to one or more service objects.)

The logic performed by a controller often results in some information that needs to be carried back to the user and displayed in the browser. This information is referred to as the model. But sending raw information back to the user isn’t sufficient, it needs to be formatted in a user-friendly format, typically HTML. For that the information needs to be given to a view, typically a JSP.

One of the last things that a controller does is package up the model data and identify the name of a view that should render the output. It then sends the request, along with the model and view name, back to the DispatcherServlet.

The view name passed back to DispatcherServlet doesn’t directly identify a specific JSP. In fact, it doesn’t even necessarily suggest that the view is a JSP at all. Instead, it only carries a logical name which will be used to look up the actual view that will produce the result. The DispatcherServlet will consult a view resolver to map the logical view name to a specific view implementation, which may or may not be a JSP. Now that DispatcherServlet knows which view will render the result, the request’s job is almost over.Its final stop is at the view implementation (probably a JSP) where it delivers the model data. The request’s job is finally done. The view will use the model data to render output that will be carried back to the client by the (not- so-hardworking) response object

Setting up Spring MVC
At the heart of Spring MVC is DispatcherServlet, a servlet that functions as Spring MVC’s front controller. Like any servlet, DispatcherServlet must be configured in the web application’s web.xml file. So the first thing we must do to use Spring MVC in our application is to place the followingdeclaration in the web.xml file:

<servlet>
        <servlet-name>Spring MVC</servlet-name>
<servlet-class> org.springframework.web.servlet.DispatcherServlet   </servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
</servlet>

To test the example Create a new Dynamic Web Project with Name SpringProGo to WEB-INF folder and create a file with name web.xml Add Dispatcher Servlet Code in web.xml

By default, when Dispatcher- Servlet is loaded, it’ll load the Spring application context from an XML file whose name is spring.xml(located in the application’s WEB-INF directory).
Next Step is to Map the Servlet

    <servlet-mapping>
        <servlet-name>Spring MVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

By mapping DispatcherServlet to /, I’m saying that it’s the default servlet and that it’ll be responsible for handling all requests, including requests for static content.Next Step is to create the spring.xml file that Dispatcher- Servlet will use to create an application context. The following listing shows the beginnings of the spring.xml file

<?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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<mvc:resources mapping="/resources/**" location="/resources/"/>
</beans>

<mvc:resources> sets up a handler for serving static content. The mapping attribute is set to /resources/**, which includes an Ant-style wildcard to indicate that the path must begin with /resources, but may include any sub path thereof. The location attribute indicates the location of the files to be served. As configured here, any requests whose paths begin with /resources will be automatically served from the /resources folder at the root of the application. Therefore all of our images, style sheets, JavaScript, and other static content needs to be kept in the application’s /resources folder.

Configuring an annotation-driven Spring MVC

As I mentioned earlier, DispatcherServlet consults one or more handler mappings in order to know which controller to dispatch a request to. Spring comes with a hand- ful of handler mapping implementations to choose from, including

BeanNameUrlHandlerMapping—Maps controllers to URLs that are based on the controllers’ bean names.
ControllerBeanNameHandlerMapping—Similar to BeanNameUrlHandlerMapping, maps controllers to URLs that are based on the controllers’ bean names. In this case, the bean names aren’t required to follow URL conventions.
ControllerClassNameHandlerMapping—Maps controllers to URLs by using the controllers’ class names as the basis for their URLs.
DefaultAnnotationHandlerMapping—Maps request to controller and control- ler methods that are annotated with @RequestMapping.
SimpleUrlHandlerMapping—Maps controllers to URLs using a property collec- tion defined in the Spring application context.

If no handler mapping beans are found, then DispatcherServlet creates and uses BeanNameUrlHandlerMapping and DefaultAnnotationHandler- Mapping.
To enable annotation for the project you need to add simply one line in splitter-servlet.xml
<mvc:annotation-driven/>
For our application HomeController is a basic Spring MVC controller that handles requests for the home page.
package com.springpro.controller;
import java.util.Map;
import javax.inject.Inject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.springpro.service.SpitterService;

@Controller
public class HomeController {

public static final int DEFAULT_SPITTLES_PER_PAGE=25;
private SpitterService spitterService;
@Inject
public HomeController(SpitterService spitterService){
this.spitterService=spitterService;
}

@RequestMapping({"/","/home"})
public String showHomePage(Mapmodel){
System.out.println("Reached here");
model.put("spittles",spitterService.getRecentSpittles(DEFAULT_SPITTLES_PER_PAGE));
return "home";
}
}
Although HomeController is simple, there’s a lot to talk about here. First, the @Controller annotation indicates that this class is a controller class.
Also we need to configure a <context:component-scan> in spitter- servlet.xml so that the HomeController class (and all of the other controllers we’ll write) will be automatically discovered and registered as beans. Here’s the relevant snippet of XML
<context:component-scan base-package="com.springpro.contoller"/>
Going back to the HomeController class, we know that it’ll need to retrieve a list of the most recent spittles via a SpitterService. Therefore, we’ve written the constructor to take a SpitterService as an argument and have annotated it with @Inject annota-tion so that it’ll automatically be injected when the controller is instantiated.
Spring.xml should look like this
<?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:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  <mvc:resources mapping="/resources/**" location="/resources/" />
  <mvc:annotation-driven/>
  <context:component-scan base-package="com.springpro"/>
  <bean>
  <property name="prefix" value="/WEB-INF/views/"/>
  <property name="suffix" value=".jsp"/>
</bean>
</beans>
To display records in JSP
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@taglib prefix="s" uri="http://www.springframework.org/tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
Top of the Page.
<c:forEach var="spittle" items="${spittles}">
   <br><c:out value="${spittle}"></c:out>
</c:forEach>
</body>
</html>
Source (Spring in Action 3)