Java Bytes

Missing Number

noreply@blogger.com (Babji Prashanth, Chetty) — Tue, 14 Feb 2012 00:08:00 +0000

Apart from a few programming puzzles, I never really got to work extensively on 'Bit Array' operations. So, as was practicing a bit, I got an idea for a problem, for which I posted a solution already (Software Job - Interview Question). This problem is about finding the missing number, in a array of unsorted numbers. For Ex: We have numbers from 1 to 52 that are put into a 51 number array, what's the best way to find out which number is missing?

As per the idea in that earlier post, the code would look like:

public class MissingNumber {
    public static void main(String[] args) {
        MissingNumber missingNum = new MissingNumber();        
        System.out.println("Missing Number : " + missingNum.findMissingNum(new int[] {3,1,2,5,4,7,9,8}, 9));
    }
    
    private int findMissingNum(int[] intArray, int n) {
        int res = 0;
        
        int sum = 0;
        for(int i=0;i<intArray.length;i++) {
            sum += intArray[i];
        }
        
        return ((n * (n + 1))/2) - sum;
    }
}

An other solution is to use Java's BitSet, as in the below listed code. Also, note that the following logic is also good for finding multiple missing numbers. So, the below code is a better approach to find one or more than one missing numbers:

public class MissingNumbers {
    public static void main(String[] args) {
        //In the below code: Array Size = 8 and n = 10.
        //So 2 missing numbers!
        int n = 10;
        int[] intArr = new int[] {3,1,2,5,4,7,10,8};
        
        MissingNumbers missingNums = new MissingNumbers();
        int[] missingNums = missingNums.findMissingNumber(intArr, n);
        
        for(int i=0;i<missingNums.length;i++) {
            System.out.println("Missing Number " + (i + 1) +  " : " + missingNums[i] + "  ");
        }
    }
    
    private int[] findMissingNumber(int[] intArray, int totalNum) {
        int numOfMissingNums = totalNum - intArray.length;
        BitSet bitSet = new BitSet(totalNum);
        
        for(int i: intArray) {
            bitSet.set(i-1);
        }
        
        int[] missingNums = new int[numOfMissingNums];
        for(int k=0;k<numOfMissingNums;k++) {
            int index = (k == 0) ? 0 : (missingNums[k - 1]);
            missingNums[k] = (bitSet.nextClearBit(index) + 1);
        }
        
        return missingNums;
    }
}

Guice - AOP (Aspect Oriented Programming)

noreply@blogger.com (Babji Prashanth, Chetty) — Sat, 01 Oct 2011 01:05:00 +0000

Aspect Oriend Programming (AOP) is a programming methodology or perspective, which was conceived to bring in more modular approach to the already existing 'Object Oriented Methodology'. Dependency Injection, which is another programming methodology to bring in more modular approach or to create loosely coupled modules, which compliments AOP. In this post, I'm going to write something about how the DI framework 'Guice' uses it's DI mechanism, to provide AOP concepts (method interceptors).

Lets think of a small application, where users need to purchase a licence or have some special privileges to use some functionality of the application. Below is the code for this app, which provides the main functionality of this app (Service.java interface and it's implementation - ServiceImpl.java):

Service.java

package com.chetty.licence;

/**
 * Service Interface
 *
 * @author Babji, Chetty
 */
public interface Service {
    public void doSomething1();
    public void doSomething2();
}

ServiceImpl.java

package com.chetty.licence;

/**
 * Service Implementation.
 * 
 * @author Babji, Chetty
 */
public class ServiceImpl implements Service {    
    public void doSomething1() {
        System.out.println("I'm doing something - 1");
    }

    @LicenceRequired
    public void doSomething2() {
        System.out.println("I'm doing something - 2");
    }
}

As you see in the above Service interface implementation, there is a annotation called "LicenceRequired" for the second method. What we are trying to do is to provide limited access to the functionality of this app or that method, by keeping a check (by intercepting) on that method, whenever it is called. The code for the "LicenceRequired" annotation is as below:

LicenceRequired.java

package com.chetty.licence;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


/**
 *
 * @author Babji, Chetty.
 */
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD)
public @interface LicenceRequired {}

Guice provides the "method interceptors" functionality by using "AOP Alliance" (aopalliance.jar) as it's external library. The annotation "LicenceRequired" is used as a marker (See ServiceImpl.java's doSomething2() method) to intercept the required method. Guice knows that this method has to be intercepted, by the following configuration (Guice Module):

LicenceModule.java

package com.chetty.licence.guice.module;

import com.chetty.licence.LicenceRequired;
import com.chetty.licence.LicenceChecker;
import com.chetty.licence.Service;
import com.chetty.licence.ServiceImpl;
import com.google.inject.AbstractModule;
import com.google.inject.matcher.Matchers;


/**
 *
 * @author b.chetty
 */
public class LicenceModule extends AbstractModule {
    protected void configure() {
        LicenceChecker licenceChecker = new LicenceChecker();
        requestInjection(licenceChecker);
        bindInterceptor(Matchers.any(), Matchers.annotatedWith(LicenceRequired.class), licenceChecker);

        bind(Service.class).to(ServiceImpl.class);
    }
}

The service client or adapter, is as follows:

ServiceAdapter.java

package com.chetty.licence;

import com.google.inject.Inject;

/**
 * Service Adapter.
 * 
 * @author Babji, Chetty
 */
public class ServiceAdapter {
    private final Service service;

    @Inject
    public ServiceAdapter(Service service) {
        this.service = service;
    }

    public void doSomething() {
        service.doSomething1();
        service.doSomething2();
    }
}

And the Licence checking functionality is done in the following class (Licence.java):

Licence.java

package com.chetty.licence;

/**
 *
 * @author Babji, Chetty
 */
public class Licence {
    public boolean checkLicence(String licenceString) {
        String licenceStringFromDB = getLicenceStringFromDB();
        return (licenceString != null && licenceStringFromDB != null && licenceString.equals(licenceStringFromDB) ? true : false);
    }

    private String getLicenceStringFromDB() {
        return "TEST";
    }
}

And below is the class, that aids the method intercepting process. If you check the Guice Configuration module (LicenceModule.java), I have configured the "LicenceRequired" annotation, to work with "LicenceChecker" class, so that when the method with business logic, annotated with "LicenceRequired" is called, control is passed over to the "LicenceChecker" class.

LicenceChecker.java

package com.chetty.licence;

import com.google.inject.Inject;
import java.util.Scanner;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
 *
 * @author Babji, Chetty
 */
public class LicenceChecker implements MethodInterceptor {
    @Inject
    private Licence licence;

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        //Get License String from the user. You can read the licence string from a licence-file, from connsole, etc options.
        //In this case, I'm just reading it from the console.
        System.out.println("You need a valid Licence to use this functionality...Please enter your Licence string: ");
        Scanner input = new Scanner(System.in);
        String licenceString = input.nextLine();
                                
        if(!licence.checkLicence(licenceString)) {
            //Here, you can either throw an exception and show a "Invalid Licence" message or customize it according to your needs.            
            System.out.println("Invalid Licence!");
            throw new IllegalStateException("Invalid Licence : " + invocation.getMethod().getName());
        }
        
        return invocation.proceed();
    }
}

And, below is the main class (entry point) for this application called "licenceCheck":

LicenceApp.java

package com.chetty.licence;

import com.chetty.licence.guice.module.LicenceModule;
import com.google.inject.Guice;
import com.google.inject.Injector;

/**
 * @author Babji, Chetty
 */
public class LicenceApp {
    public static void main(String[] args) {        
        Injector injector = Guice.createInjector(new LicenceModule());
        ServiceAdapter serviceInterface = injector.getInstance(ServiceAdapter.class);
        serviceInterface.doSomething();
    }
}

This app uses a hardcoded "TEST" string as licence string. This is checked with the user input licence string and if they don't match, the method with "LicenceRequired" annotation will not be executed. If you execute the application with a test string "TEST1234", "I'm doing something - 1" is printed, followed by "Invalid Licence!" and an IllegalStateExcception (implying that the second method - doSomething2() is not executed). If the user input licence string is "TEST", both the methods are executed. This idea can be customized and implemented in your own projects. There are also other uses of this AOP in handling transactions, logging, security, etc.

You can get the source code for this app, on Google's code repository: licenceCheck

Disclaimer: This sample project was created for fun and to learn new techniques. Use the code, at your own risk! :P

Creating Executable Jar File With Maven Shade Plugin

noreply@blogger.com (Babji Prashanth, Chetty) — Sat, 01 Oct 2011 01:02:00 +0000

In a couple of Java projects with external jar files as dependencies, you can create an executable jar file by the following ways:

1) Include the sources of external libraries in your project and build them, as part of your project build process.
2) Unpack the jar file, pack them inside your project and create a single executable jar file.

For maven users, fortunately, there is "Maven Shade Plugin", which does the work for you, probably using the second option, as described above. Even if there wasn't a plugin, I guess, it ain't that difficult to build one. To use that plugin, all you have to do is to include the following tag in your project's pom.xml:


        
            
                org.apache.maven.plugins
                maven-shade-plugin
                1.4
                
                  
                    package
                    
                      shade
                    
                    
                      
                        
                          Main Class of the jar file

Java - Looping Through A Range of BigInteger Values

noreply@blogger.com (Babji Prashanth, Chetty) — Mon, 23 May 2011 21:46:00 +0000

Recently, I was just coding something and came across a situation, where I'd to loop through a range of BigInteger values. I'd to think a bit to work on this, as I haven't worked extensively on arbitrary precision arithmetic. Below is an example of how to loop through a range of BigInteger values:

import java.math.BigInteger;

public class BigIntTest {
 public static void main(String[] args) {
  BigInteger bigInt1 = new BigInteger("1000000000000000");
  BigInteger bigInt2 = new BigInteger("1000000000000500");
  
  //Loop from bigInt1 to bigInt2
  for(BigInteger bigInt = bigInt1; bigInt.compareTo(bigInt2) < 0; bigInt = bigInt.add(BigInteger.ONE)) {
   System.out.println("I'm so big now : " + bigInt);
  }
 }
}

Software Job - Interview Question

noreply@blogger.com (Babji Prashanth, Chetty) — Sat, 19 Jun 2010 23:09:00 +0000

Today, I was searching for some technical articles and stumbled upon this interview question from Amazon, for which I could immediately think about some good solution. Here's the question:

We have numbers from 1 to 52 that are put into a 51 number array, what's the best way to find out which number is missing?

I read an answer from some guy, who said to sort the numbers first and then loop through and find the number. I thought that was inefficient way of doing that. My answer is as below:

1) - Calculate the sum of all numbers stored in the array of size 51. 
2) - Subtract the sum from (52 * 53)/2 &nbsp; -- Formula : n (n+1)/2.

The result of subtraction is the answer for this question.

Any other solutions that you know of?!?!?!

Code Bubbles

noreply@blogger.com (Babji Prashanth, Chetty) — Tue, 13 Apr 2010 21:12:00 +0000

So far, I have developed code on different IDE's (Integrated Development Environment) like Kawa, IntelliJ, Netbeans, Eclipse and others, but pretty curious to know how this new IDE called 'Code Bubbles' would be. Here's a demo from 'em:

Create Your Own Dependency Injection Framework

noreply@blogger.com (Babji Prashanth, Chetty) — Sat, 03 Apr 2010 01:24:00 +0000

Inspired by the latest developments in Java and other open source frameworks like Guice, today I worked for a couple of hours on creating a small dependency injection framework (on the lines of guice), which I named it as 'Funny Dependency Injection' framework. This framework has only one custom annotation, which annotates a constructor, to provide dependency injection (only constructor injection in this example). Here's the code for the 'Shoot' annotation:

Shoot.java

package com.chetty.shoot;

import java.lang.annotation.Documented;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Target;

@Target({ METHOD, CONSTRUCTOR, FIELD })
@Retention(RUNTIME)
@Documented
public @interface Shoot {}

And here's the client class, for which the 'Shoot' annotation is used:

Client.java

package com.chetty.client;

import com.chetty.service.NewService;
import com.chetty.service.Service;
import com.chetty.shoot.Shoot;

public class Client {
	private Service service;
	private NewService newService;
	
	@Shoot
	public Client(Service service, NewService newService) {
		this.service = service;
		this.newService = newService;
	}
	
	public void doSomething() {
		service.serve();
		newService.doSomethingNew();
	}
}

In the above class, you can see the 2 parameters for Client's constructor. These dependencies will be injected at runtime, with the help of "Shoot" annotation. The 'Service' and the 'NewService' interfaces are listed below:

Service.java

package com.chetty.service;

public interface Service {
 public void doSomething();
}

NewService.java

package com.chetty.service;

public interface NewService {
	public void doSomethingNew();
}

And here are 2 implementations of 'Service' interface:

ServiceImpl1.java

package com.chetty.service;

public class ServiceImpl1 implements Service {
 @Override
 public void doSomething() {
  System.out.println("I'm doing something in ServiceImpl1");  
 }
}

ServiceImpl2.java

package com.chetty.service;

public class ServiceImpl2 implements Service {
 @Override
 public void doSomething() {
  System.out.println("I'm doing something in ServiceImpl2");  
 }
}

And here's an implementation for 'NewService' interface:

NewServiceImpl1.java

package com.chetty.service;

public class NewServiceImpl1 implements NewService {
	@Override
	public void doSomethingNew() {
		System.out.println("I'm doing something new!");
	}
}

Below are 2 classes, which are part of this funnyDI framework..and which are used for configuration (dependency mapping information):

IModule.java

package com.chetty.module;

public interface IModule {
	void configure();
	 Class getMapping(Class type);
}

AbstractModule.java

package com.chetty.module;

import java.util.HashMap;
import java.util.Map;

abstract class AbstractModule implements IModule {
	private Map, Class> classMap = new HashMap, Class>();
	
	public abstract void configure();
		
	 void createMapping(Class baseClass, Class subClass) {
		classMap.put(baseClass, subClass.asSubclass(baseClass));
	}
		
	public  Class getMapping(Class type) {
		Class implementation = classMap.get(type);
		
	    if(implementation == null) 
	      throw new IllegalArgumentException("Couldn't find the mapping for : " + type);
	    
	    return implementation.asSubclass(type);
	}
}

And below is the class used for configuration by the user of 'funnyDI' framework, to provide configuration (dependency mapping information):

Module.java

package com.chetty.module;

import com.chetty.service.NewService;
import com.chetty.service.NewServiceImpl1;
import com.chetty.service.Service;
import com.chetty.service.ServiceImpl2;

public class Module extends AbstractModule {
	public void configure() {		
		createMapping(Service.class, ServiceImpl2.class);
		createMapping(NewService.class, NewServiceImpl1.class);
	}
}

And here's the core class of this funny dependency injection framework, which uses java reflection to find the dependency and inject it:

Shooter.java

package com.chetty.shoot;

import java.lang.reflect.Constructor;

import com.chetty.module.IModule;

public class Shooter {
	private IModule module;
	
	public Shooter(IModule module) {
		this.module = module;		
	}
	
	@SuppressWarnings("unchecked")
	public Object fireShot(Class klass) throws Exception {		
		if(klass != null) {			
			boolean flag = true;
			int index = 0;
			
			for(Constructor constructor: klass.getConstructors()) {				
				if(constructor.isAnnotationPresent(Shoot.class)) {
					if(flag && index == 0) { //To restrict to only one constructor injection
						flag = false;
						index++;
												
						Class[] parameterTypes = constructor.getParameterTypes();
						Object[] objArr = new Object[parameterTypes.length];
						
						int i = 0;
						
						for(Class c : parameterTypes) {
							Class dependency = module.getMapping(c);
																											
							if(c.isAssignableFrom(dependency)) {								
								objArr[i++] = dependency.getConstructor().newInstance();						
							}
						}
						
						Object resObj = klass.getConstructor(parameterTypes).newInstance(objArr);						
						
						return resObj;
					}					
				}
			}
		}
		
		return null;		
	}
}

There's one more class that is part of this funny DI framework, which initializes the configuration (based on the configuration module used) and returns the 'Shooter' class, which further provides the dependency injection:

FunnyDI.java

package com.chetty.shoot;

import com.chetty.module.IModule;

public class FunnyDI {
	public static Shooter getShooter(IModule module) {
		module.configure();
		return new Shooter(module);		
	}
}

And here's the main java class, which acts as a entry point for this funny application, which uses 'Funny Dependency Injection':
FunnyApp.java

package com.chetty.funny;

import com.chetty.client.Client;
import com.chetty.module.Module;
import com.chetty.shoot.FunnyDI;
import com.chetty.shoot.Shooter;

public class FunnyApp {
	public static void main(String[] args) throws Exception {
		Shooter shooter = FunnyDI.getShooter(new Module());
		
		Client client = (Client) shooter.fireShot(Client.class);
		
		client.doSomething();
	}
}

Thats it! When I ran the above program, "I'm doing something in ServiceImpl2" is printed, followed by "I'm doing something new", in the next line.

You can find the source code for this funny DI framework on funnydi. If you have any funny comments, please don't hesitate to post! ;)

DISCLAIMER: The code posted above was created for fun and to learn something new. The above framework needs to be improvised a lot, if you want to implement it, in your own project. So, don't use it blindly.

Google Guice - Example

noreply@blogger.com (Babji Prashanth, Chetty) — Sun, 21 Feb 2010 01:03:00 +0000

Dependency Injection and Google's Guice framework need no introduction from me, as the documentation on Google's project hosting site is pretty good. Also, there are loads of articles and other information related to these topics, on the internet. So, I will start off with a pretty basic java project, to show 'Guice' in action.

Okay...Now lets think of a very small framework/project (so that, it will be easy to understand) to calculate the sum of all consecutive integers from 1 to n. You are given 'n' as the input and you are supposed to output the sum of all consecutive integers from 1 to n. Lets imagine that there is only one implementation, that we know of (at that moment), to implement the solution...but lets stick to a good design procedure of object oriented languages and make it flexible for future changes.

Below is the code for the only implementation that I know of, at that moment:

IMathAdditionService:

package com.chetty.service;

public interface IMathAdditionService {
public int sumOfAllConsecutiveNumbers(int n);
}

SnailAdditionService (implements IMathAdditionService):

package com.chetty.service;

public class SnailAdditionService implements IMathAdditionService {
@Override
public int sumOfAllConsecutiveNumbers(int n) {  
int sum = 0;
long startTime = System.nanoTime();

for(int i=1;i<=n;i++) {
sum += i;
}

long endTime = System.nanoTime();

System.out.println("Snail Addition Service - Sum : " + sum);
System.out.println("Time Complexity - O(n) and Time Taken : " + (endTime - startTime));
return sum;
}
}

Okay, now lets create an interface/client for this service (NOTE: I assume, you know something about 'Factory Pattern'. If not, check it here!). If you implement the 'Factory Pattern', this is how the code looks like: MathServiceFactory:

package com.chetty.service;

public class MathServiceFactory {
private MathServiceFactory() {}
private static IMathAdditionService mathService = new SnailAdditionService();

public static IMathAdditionService getInstance() {
return mathService;
}

public static void setInstance(IMathAdditionService service) {
mathService = service;
}
}

MathClient:

package com.chetty.client;

import com.chetty.service.IMathAdditionService;
import com.chetty.service.MathServiceFactory;

public class MathClient {
public void go() {
IMathAdditionService mathService = MathServiceFactory.getInstance();
mathService.sumOfAllConsecutiveNumbers(1000);
}
}

Implementing the factory pattern makes it a bit loosely coupled, but doesn't really take off the dependencies. Also, you would have to provide different factories for new/different implementations. This is where 'Dependency Injection' comes in handy and Google's Guice is one of the frameworks created to provide DI techniques. Below is the code, which uses 'Constructor Injection' and the Guice's 'Inject' annotation, to inject the required service, at runtime. This kind of approach is more flexible, has less code and you can bind/implement new services (or service providers) just by a minimal change in code/configuration. For the same reason, it is also easier to test the code. 'Plug n Play', 'Service Oriented Arhcitecture (SOA)', 'Webservices' come to mind, when you think about this kind of loosely coupled stuff. Below is the implementation of the client using Guice:

package com.chetty.client;

import com.chetty.service.IMathAdditionService;
import com.google.inject.Inject;

public class MathClient {
private final IMathAdditionService mathService;

@Inject
public MathClient(IMathAdditionService mathService) {
this.mathService = mathService;
}

public int sumOfAllConsecutiveNumbers(int n) {
return mathService.sumOfAllConsecutiveNumbers(n);
}
}

Apart from this, you would have to create a module (which provides/replaces the factory class implementation): MathModule:

package com.chetty.module;

import com.chetty.service.IMathAdditionService;
import com.chetty.service.SnailAdditionService;
import com.google.inject.AbstractModule;

public class MathModule extends AbstractModule {
@Override
protected void configure() {
bind(IMathAdditionService.class).to(SnailAdditionService.class);
}
}

As you see in the code above, this is the class where the required service is configured for use, by the client. In the future, if you have a new implementation for the client, all you have to do is to change the configuration. This technique sticks better to the 'Open Closed Principle', than the factory implementation. And below is the main class, where you use the Guice's injector:

package com.chetty.client;

import com.chetty.module.MathModule;
import com.chetty.service.IMathAdditionService;
import com.google.inject.Guice;
import com.google.inject.Injector;

public class MathApp {
public static void main(String[] args) {
Injector injector = Guice.createInjector(new MathModule());

MathClient mathClient = injector.getInstance(MathClient .class);

mathClient.sumOfAllConsecutiveNumbers(1000);
}
}

Ok...At some point later, I got to know a new algorithm/technique to find the sum of all consecutive integers from 1 to n. So, I want to hook up this new solution to the client, which is faster and has less code. Below is the code for that: FastAdditionService:

package com.chetty.service;

public class FastAdditionService implements IMathAdditionService {
@Override
public int sumOfAllConsecutiveNumbers(int n) {
long startTime = System.nanoTime();
int sum = (n * (n+1))/2;
long endTime = System.nanoTime();

System.out.println("Fast Addition Service - Sum : " + sum);
System.out.println("Time Complexity - O(1) and Time Taken : " + (endTime - startTime));
return sum;
}
}

All that you have to do now, is to extend the framework (but no modifications) with this new service and change the configuration in the module class (MathModule.java), as below:

bind(IMathAdditionService.class).to(FastAdditionService.class);

Looking at the Module class used for configuration, you might be wondering why we are providing configuration in a Java class, instead of the usual way of using XML or bundles/properties files.....Well, it has a reason...The reason is to provide a tight binding (for configuration) and catch all errors at compile time, so that there will be no untoward exceptions/errors on production, at runtime.

Guice Grapher - Example

noreply@blogger.com (Babji Prashanth, Chetty) — Sat, 20 Feb 2010 04:15:00 +0000

Guice provides a 'Grapher' module, as an extension to its framework, to visualize the bindings and the application structure. This module is not yet available in the guice-2.0 version (and is not packed in any of the jar files of this version), but you can download the source code from the Guice's SVN repository and build it for use.

Guice's Grapher module finds all the bindings used for a particular injector and generates a DOT file (plain text graph description language). If you have already installed 'GraphViz', you can use the GVEdit.exe to run these DOT files and generate the schematic of an application using Guice's bindings.

For the example from my other post, I just copied all the sources under 'com.google.inject.grapher', built my project and ran the main java class, which looks as below:

package com.chetty.client;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;

import com.chetty.module.MathModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.grapher.GrapherModule;
import com.google.inject.grapher.InjectorGrapher;
import com.google.inject.grapher.graphviz.GraphvizModule;
import com.google.inject.grapher.graphviz.GraphvizRenderer;

public class MathApp {
public static void main(String[] args) throws IOException {
Injector injector = Guice.createInjector(new MathModule());

MathClient mathClient = injector.getInstance(MathClient.class);

mathClient.sumOfAllConsecutiveNumbers(1000);

PrintWriter out = new PrintWriter(new File("c://MathAppGraph.dot"), "UTF-8");

Injector graphInjector = Guice.createInjector(new GrapherModule(), new GraphvizModule());
GraphvizRenderer renderer = graphInjector.getInstance(GraphvizRenderer.class);
renderer.setOut(out).setRankdir("TB");

graphInjector.getInstance(InjectorGrapher.class)
.of(injector)
.graph();
}
}

Running this class, generated a DOT file, which when opened with GraphViz's Editor, looks like:

The above pic, generated from my example project doesn't show much. So, lets use the example bundled with the Guice Source code (under 'extensions'). Using this example, the grapher modules, generates the DOT file, for the following pic:

Using Richfaces 'Suggestion Box' As Combo Box

noreply@blogger.com (Babji Prashanth, Chetty) — Mon, 19 Oct 2009 18:14:00 +0000

If you had already tried to use Richfaces Combo Box for populating the 'id-value' pairs, you would have noticed that the dropdown/combo box will be populated with id's, rather than values. It's not a bug or a problem with richfaces framework, but a different design. There's a workaround for this, which lets you use the 'Richfaces Suggestion Box' component, to work like a combo box or a dropdown list.

Below is the sample code snippet from a facelets file, which acts like a combo box:

<a4j:form id="form1">

...............

...............

<h:outputText value="Key :"/>
<a4j:region selfRendered="true" id="region1">
<h:inputText id="value" value="Value : "/>
<h:graphicImage value="arrow.png" 
onclick="openSuggestionBox('suggestion','form1','value','');" 
alt=""/>

<rich:suggestionbox id="suggestion" for="value" 
suggestionAction="#{someBean.fill}"  var="result" ignoreDupResponses="true">
<h:column>
<h:outputText value="#{result.description}"/>
</h:column>

<a4j:support event="onselect">
<f:setPropertyActionListener value="#{result.id}" 
target="#{someBean.selId}"/>
</a4j:support>
</rich:suggestionbox>
</a4j:region>
</a4j:form>

In the above code, I'm using a arrow image (down arrow) beside the input text box, to make it look like a combo-box/drop-down list and created a javascript function, which is called on click of that arrow image. This javascript function does nothing special, but clears the text-box and calls the actual 'Suggestion Box' method (creates an AJAX request).

And below is the Javascript code for 'openSuggestion' function:

Hashcode Of A String In Java

noreply@blogger.com (Babji Prashanth, Chetty) — Mon, 05 Oct 2009 19:25:00 +0000

Many of the Java programmers know what 'Hashcode' means, but don't really know how exactly it is calculated and why 31 is used to calculate the hashcode. Below is the code snippet from Java 1.6, which calculates the hashcode for a string:

public int hashCode() {
int h = hash;
if (h == 0) {
int off = offset;
char val[] = value;
int len = count;

for (int i = 0; i < len; i++) {
h = 31*h + val[off++];
}
hash = h;
}

return h;
}

Even if someone knows why 31 is used, there is a lot of stuff to know about 'Hashing', 'Hash Collisions' and multiple algorithms related to calculating hash values. First off, its a known fact that there is no perfect hashing algorithm, for which there are no collisions. But there are several algorithms, which minimize the collisions and are good enough to use. Now, coming to why 31 is used in calculating hashcode, this is the reason given by Joshua Bloch, in the book 'Effective Java':

The value 31 was chosen because it is an odd prime. If it were even and the multiplication overflowed, information would be lost, as multiplication by 2 is equivalent to shifting. The advantage of using a prime is less clear, but it is traditional. A nice property of 31 is that the multiplication can be replaced by a shift and a subtraction for better performance: 31 * i == (i << 5) - i. Modern VMs do this sort of optimization automatically.

This wasn't sufficient for me, to understand why 31 is used. I did a bit of research and found some good links, providing some info about why 31 is used. Here are some links with very good info: Stack Overflow - Why does java hashcode use 31 as a multiplier Apart from the above link, there are a couple of other links with pretty good info about hashing, hash collisions and performance of hashing algorithms: Consistency Of Hashcode On A Java String Best Hashing Algos, In Terms Of Collisions and Performance Java Array Hashcode Implementation

After reading up a bit, I wrote a sample test Java program, to find the hashcode of a string by multiplying by 31 (which is the same as shifting left (bitwise) by 5 times and subtracting, as in (i << 5) - i). Below is the sample test program:

public class TestHash {
public static void main(String[] args) {
String str1 = "What the heck?";

int hashcode1 = 0;
int hashcode2 = 0;

for(int i=0;i<str1.length();i++) {
hashcode1 = 31*hashcode1 + str1.charAt(i);
hashcode2 = (hashcode2 << 5) - hashcode2 + str1.charAt(i);
}

System.out.println("Hashcode1 : " + hashcode1);
System.out.println("Hashcode2 : " + hashcode2);
}
}

The output for this program is:

Hashcode1 : 277800975
Hashcode2 : 277800975

Apart from the above info, I want to share some info from the recent article on java.sun.com, written by Joseph Darcy. It was an interesting case of 'Unhashing' - Reverse Engineering Hashcode, To Find A String That Collides With The Actual String. This was an interesting way of finding 'Hash Collisions'. I then tested the code from Joseph Darcy, by writing a sample program, as below:

public class TestHash {
/**
* @author - Babji P, Chetty
*/
public static void main(String[] args) {
String str1 = "what the heck?";

int hashcode1 = 0;
int hashcode2 = 0;

for(int i=0;i<str1.length();i++) {
hashcode1 = 31*hashcode1 + str1.charAt(i);
hashcode2 = (hashcode2 << 5) - hashcode2 + str1.charAt(i);
}

System.out.println("Hashcode1 : " + hashcode1);
System.out.println("Hashcode2 : " + hashcode2);

String str2 = unhash(hashcode1);
System.out.println("Unhashed String From Hashcode : " + str2);

int hashcode3 = 0;
int hashcode4 = 0;

for(int i=0;i<str2.length();i++) {
hashcode3 = 31*hashcode3 + str2.charAt(i);
hashcode4 = (hashcode4 << 5) - hashcode4 + str2.charAt(i);
}

System.out.println("Hashcode3 : " + hashcode3);
System.out.println("Hashcode4 : " + hashcode4);

}

/**
* Returns a string with a hash equal to the argument.
* @return string with a hash equal to the argument.
* @author - Joseph Darcy
*/
public static String unhash(int target) {
StringBuilder answer = new StringBuilder();
if (target < 0) {
// String with hash of Integer.MIN_VALUE, 0x80000000
answer.append("\u0915\u0009\u001e\u000c\u0002");

if (target == Integer.MIN_VALUE)
return answer.toString();
// Find target without sign bit set
target = target & Integer.MAX_VALUE;
}

unhash0(answer, target);
return answer.toString();
}

/**
* 
* @author - Joseph Darcy
*/
private static void unhash0(StringBuilder partial, int target) {
int div = target / 31;
int rem = target % 31;

if (div <= Character.MAX_VALUE) {
if (div != 0)
partial.append((char)div);
partial.append((char)rem);
} else {
unhash0(partial, div);
partial.append((char)rem);
}
}
}

The output for the above program is:

Hashcode1 : 1279794159
Hashcode2 : 1279794159
Unhashed String From Hashcode : ?☻§◄
Hashcode3 : 1279794159
Hashcode4 : 1279794159

So the strings "what the heck?" and "?☻§◄" have the same hashcode. What the heck?!?!

Richfaces - Modal Panel As A Wizard

noreply@blogger.com (Babji Prashanth, Chetty) — Thu, 25 Jun 2009 17:58:00 +0000

Richfaces 'Modal Panel' component can be used to create a 'Dialog Box' or a 'Wizard' (or Wizard like behaviour), which is useful, when some part of the website/application has to ask for the input from the user, in steps. It can be customized, as per the requirements of that particular application, although everything that you implement doesn't sound like a standard mechanism, from the 'Richfaces' AJAX framework. Below is an example of creating a 'Wizard' out of a 'Richfaces Modal Panel' component:

1) Lets suppose that this 'Wizard' is opened, when a user clicks on some link (or any other AJAX/Javascript event)...and 2 steps, for that Wizard. So, the modal panel is on one page and there would be 2 other pages that are to be included, in the modal panel, to get that 'Wizard' like behavior. In my case, I'm using JSF and Facelets (Xhtml files). Below is a code snippet for the main page (where the modal panel is included):

<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:ui="http://java.sun.com/jsf/facelets"
      xmlns:rich="http://richfaces.org/rich"
      xmlns:a4j="http://richfaces.org/a4j">

  <ui:composition>
    ...........
    ...........
    ............
  
    <rich:modalPanel id="panel1">
      <f:facet name="header">
              <h:outputText value="Test" />
          </f:facet>
  
          <f:facet name="controls">
              <h:commandLink value="Close"
              style="cursor:pointer" 
              onclick="Richfaces.hideModalPanel('panel1')" />
          </f:facet>
          
          <a4j:include binding="#{someBean.include}" viewId="/view/include1.xhtml"/>
    </rich:modalPanel>
  </ui:composition>
</html>

2) And below is the code snippet, for the first included page, on the modal panel:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:ui="http://java.sun.com/jsf/facelets"
      xmlns:rich="http://richfaces.org/rich"
      xmlns:a4j="http://richfaces.org/a4j">

  <ui:composition>
    ...........
    ...........
    ............
  
    <h:form>
      <h:panelGrid columns="2">
        <h:outputText value="#{msg.input}"
        <h:inputText value="#{someBean.someText}"/>
        
        <rich:spacer width="20"/>
        <a4j:commandButton value="#{msg.submit}" action="include2" reRender="wizard"/>
    </h:panelGrid>      
   </h:form>
  </ui:composition>
</html>

Note that the above included page, doesn't need to have f:view tags. Also, there are a couple of important points to consider from the Richfaces documentation:

RichFaces allows to organize a page flow inside the component. This is a typical scenario for Wizard like behavior. The new content is rendered inside the area. The content is taken from the navigation rule of the faces configuration file (usually, the faces-config.xml). Note, that the content of the "wizard" is not isolated from the rest of the page. The included page should not have own (it does not matter if you use facelets). You need to have an Ajax component inside the to navigate between the wizard pages. Otherwize, the whole page update will be performed.

If you want to involve the server side validators and navigate to the next page only if the Validation phase is passed successfully, you can replace with and point to the action method that navigates to the next page. If Validation process fails, the partial page update will occur and you will see an error message. Otherwize, the application proceeds to the next page. Make sure, you define option for the navigation rule to avoid memory leaks.

3) And below is the "include2.xhtml", which is shown as a second step, for that wizard. This wizard appears only if the validation succeeds on the previously included page (in case, if you have any input validations).

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:ui="http://java.sun.com/jsf/facelets"
      xmlns:rich="http://richfaces.org/rich"
      xmlns:a4j="http://richfaces.org/a4j">

  <ui:composition>
    ...........
    ...........
    ............
  
    <h:form>        
       <a4j:commandButton value="#{msg.confirm}" action="#{someBean.doSomeBusinessShit}" reRender="someId,wizard"/>
       <a4j:commandButton value="#{msg.cancel}" action="#{someBean.reset}" onclick="javascript:Richfaces.hideModalPanel('panel1')" reRender="wizard"/>            
    </h:form>
  </ui:composition>
</html>

4) And the faces-config.xml configuration, is as follows:

<?xml version="1.0"?>
<!DOCTYPE faces-config PUBLIC "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN"
                              "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">
<faces-config>
   ............
   ............
   ............
   
   <navigation-rule>
        <from-view-id>/view/include1.xhtml</from-view-id>
        <navigation-case>
                <from-outcome>include2</from-outcome>
                <to-view-id>/view/include2.xhtml</to-view-id>
        </navigation-case>
    </navigation-rule>   
</faces-config>

...And hey, its not yet over. If you happened to implement the above stuff and if you navigated to the second step, clicked 'Cancel' and tried to open the 'Wizard' again, the second included page, opens up directly, without the first step (included page). To remedy this, I've to reset the "viewId" in the "a4j:include" component. The "a4j:include" tag, already includes a binding. The only thing that has to be done is to implement the "reset" method, as below:

package echo;

import org.ajax4jsf.component.html.Include;

public class SomeBean {
  .........
  .........
  private Include include;
  
  .......
  .......
  .......
  
  public void reset() {
    include.setViewId("/view/include1.xhtml");    
  }
}

Jasper Reports - Thermometer Report

noreply@blogger.com (Babji Prashanth, Chetty) — Sat, 13 Jun 2009 06:25:00 +0000

Below is the code of 'ThermoBean', which holds the data for 'Thermometer Report':

package com.chetty.reporting.beans;

public class ThermoBean {
private String title;
private double value;
private double rangeMin;
private double rangeMax;
private double firstSubRangeMin;
private double firstSubRangeMax;
private double secondSubRangeMin;
private double secondSubRangeMax;
private double thirdSubRangeMin;
private double thirdSubRangeMax;

public void setTitle(String title) {
this.title = title;
}

public String getTitle() {
return title;
}

public void setValue(double value) {
this.value = value;
}

public double getValue() {
return value;
}

public void setRangeMin(double rangeMin) {
this.rangeMin = rangeMin;
}

public double getRangeMin() {
return rangeMin;
}

public void setRangeMax(double rangeMax) {
this.rangeMax = rangeMax;
}

public double getRangeMax() {
return rangeMax;
}

public void setFirstSubRangeMin(double firstSubRangeMin) {
this.firstSubRangeMin = firstSubRangeMin;
}

public double getFirstSubRangeMin() {
return firstSubRangeMin;
}

public void setFirstSubRangeMax(double firstSubRangeMax) {
this.firstSubRangeMax = firstSubRangeMax;
}

public double getFirstSubRangeMax() {
return firstSubRangeMax;
}

public void setSecondSubRangeMin(double secondSubRangeMin) {
this.secondSubRangeMin = secondSubRangeMin;
}

public double getSecondSubRangeMin() {
return secondSubRangeMin;
}

public void setSecondSubRangeMax(double secondSubRangeMax) {
this.secondSubRangeMax = secondSubRangeMax;
}

public double getSecondSubRangeMax() {
return secondSubRangeMax;
}

public void setThirdSubRangeMin(double thirdSubRangeMin) {
this.thirdSubRangeMin = thirdSubRangeMin;
}

public double getThirdSubRangeMin() {
return thirdSubRangeMin;
}

public void setThirdSubRangeMax(double thirdSubRangeMax) {
this.thirdSubRangeMax = thirdSubRangeMax;
}

public double getThirdSubRangeMax() {
return thirdSubRangeMax;
}
}

And below is the class file with business logic, used to generate a collection of 'ThermoBean' objects, which is passed on to the Jasper reporting engine, to dynamically generate the Thermometer report:

package com.chetty.reporting.business;

import java.util.ArrayList;

import com.chetty.reporting.beans.ThermoBean;

public class ThermoBeanMaker {
public ArrayList getThermoData() {
ArrayList thermoBeanList = new ArrayList();

thermoBeanList.add(create(-10.0, -40.0, 50.0, -40.0, 0.0, 0.0, 15.0, 15.0, 50.0));

return thermoBeanList;
}

private ThermoBean create(double value, double rangeMin, double rangeMax, double firstSubRangeMin, 
double firstSubRangeMax, double secondSubRangeMin, double secondSubRangeMax, 
double thirdSubRangeMin, double thirdSubRangeMax) {
ThermoBean thermoBean = new ThermoBean();

thermoBean.setTitle("Germany - Temparature Report");
thermoBean.setValue(value);
thermoBean.setRangeMin(rangeMin);
thermoBean.setRangeMax(rangeMax);
thermoBean.setFirstSubRangeMin(firstSubRangeMin);
thermoBean.setFirstSubRangeMax(firstSubRangeMax);
thermoBean.setSecondSubRangeMin(secondSubRangeMin);
thermoBean.setSecondSubRangeMax(secondSubRangeMax);
thermoBean.setThirdSubRangeMin(thirdSubRangeMin);
thermoBean.setThirdSubRangeMax(thirdSubRangeMax);

return thermoBean;
}
}

And below is the main class, that generates the report:

package com.chetty.reporting.engine;

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import com.chetty.reporting.beans.GanttChartBean;
import com.chetty.reporting.beans.PieChartBean;
import com.chetty.reporting.beans.ThermoBean;
import com.chetty.reporting.business.GanttChartBeanMaker;
import com.chetty.reporting.business.PieChartBeanMaker;
import com.chetty.reporting.business.ThermoBeanMaker;

import net.sf.jasperreports.engine.JasperCompileManager;
import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.design.JasperDesign;
import net.sf.jasperreports.engine.xml.JRXmlLoader;

public class Reporter {
@SuppressWarnings("unchecked")
public static void main(String[] args) throws Exception {
InputStream inputStream = new FileInputStream ("reports/thermochart.jrxml");

ThermoBeanMaker thermoBeanMaker = new ThermoBeanMaker();
ArrayList thermoBeanList = thermoBeanMaker.getThermoData();

JRBeanCollectionDataSource beanColDataSource = new JRBeanCollectionDataSource(thermoBeanList);

Map parameters = new HashMap();

JasperDesign jasperDesign = JRXmlLoader.load(inputStream);
JasperReport jasperReport = JasperCompileManager.compileReport(jasperDesign);
JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, parameters, beanColDataSource);
JasperExportManager.exportReportToPdfFile(jasperPrint, "c:/reports/thermochart.pdf"); 
}
}

When you run the above class, the following report is generated:

Thermometer Report

You can find the report design file, here: thermochart.jrxml

Jasper Reports - Gantt Chart

noreply@blogger.com (Babji Prashanth, Chetty) — Fri, 12 Jun 2009 04:17:00 +0000

Jasper Reports framework uses JFreeChart, to dynamically generate charts in a Java application. In this post, I'm gonna use the Java beans as data holders and pass a collection of these beans, to the Jasper reporting engine, to dynamically generate these reports. Below is the code for the Java bean:

package com.chetty.reporting.beans;

import java.util.Date;

public class GanttChartBean {
private String series;
private String task;
private Date startDate;
private Date endDate;

public void setSeries(String series) {
this.series = series;
}

public String getSeries() {
return series;
}

public void setTask(String task) {
this.task = task;
}

public String getTask() {
return task;
}

public void setStartDate(Date startDate) {
this.startDate = startDate;
}

public Date getStartDate() {
return startDate;
}

public void setEndDate(Date endDate) {
this.endDate = endDate;
}

public Date getEndDate() {
return endDate;
}
}

And below is the code for the Java class, that holds the business logic for creating these beans:

package com.chetty.reporting.business;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;

import com.chetty.reporting.beans.GanttChartBean;

public class GanttChartBeanMaker {
public ArrayList getGanttChartData() {
ArrayList ganttChartDataList = new ArrayList();

Calendar calendar = Calendar.getInstance();

for(int i=1;i<8;i++) {
calendar.set(Calendar.HOUR_OF_DAY, i*1);

Date startDate = calendar.getTime();

calendar.set(Calendar.HOUR_OF_DAY, i*3);

Date endDate = calendar.getTime();

String series = (i % 2 == 0) ? "High Priority" : "Normal";

ganttChartDataList.add(create(series, "Meeting" + i, startDate, endDate));
}

return ganttChartDataList;
}

private GanttChartBean create(String series, String task, Date startDate, Date endDate) {
GanttChartBean ganttChartBean = new GanttChartBean();

ganttChartBean.setSeries(series);
ganttChartBean.setTask(task);
ganttChartBean.setStartDate(startDate);
ganttChartBean.setEndDate(endDate);

return ganttChartBean;
}
}

And below is the main class, which passes the collection of beans, to the Jasper reporting engine, to dynamically generate the Gantt Chart:

package com.chetty.reporting.engine;

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import com.chetty.reporting.beans.GanttChartBean;
import com.chetty.reporting.beans.PieChartBean;
import com.chetty.reporting.business.GanttChartBeanMaker;
import com.chetty.reporting.business.PieChartBeanMaker;

import net.sf.jasperreports.engine.JasperCompileManager;
import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.design.JasperDesign;
import net.sf.jasperreports.engine.xml.JRXmlLoader;

public class Reporter {
@SuppressWarnings("unchecked")
public static void main(String[] args) throws Exception {
InputStream inputStream = new FileInputStream ("reports/ganttchart.jrxml");

GanttChartBeanMaker ganttChartBeanMaker = new GanttChartBeanMaker();
ArrayList ganttChartBeanList = ganttChartBeanMaker.getGanttChartData();

JRBeanCollectionDataSource beanColDataSource = new JRBeanCollectionDataSource(ganttChartBeanList);

Map parameters = new HashMap();

JasperDesign jasperDesign = JRXmlLoader.load(inputStream);
JasperReport jasperReport = JasperCompileManager.compileReport(jasperDesign);
JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, parameters, beanColDataSource);
JasperExportManager.exportReportToPdfFile(jasperPrint, "c:/reports/ganttchart.pdf"); 
}
}

When you run the code, the following report is generated: Gantt Chart The above report uses a different theme, which is not present in the jasperreports.jar file. To use that theme, you would have to include the 'jasperreports-chart-themes.jar' file. You can find the report design file, for the above report, here: ganttchart.jrxml

Jasper Reports - Example

noreply@blogger.com (Babji Prashanth, Chetty) — Thu, 11 Jun 2009 05:12:00 +0000

Jasper Reports is one of the best 'Business Intelligence (BI)' tools/frameworks, which can be used for generating reports for Java/Groovy applications. It is just partly 'Open Source', but if you can practice or have good enough work experience in Java, you can easily build basic/complex reports.

'Jasper Reports' framework can handle different kinds of data sources, but in this post I will show how to generate a basic report, just by passing a collection of Java data objects (Java beans), to the Jasper Report Engine. Below is the code for the data object (Java bean):

package com.chetty.reporting.beans;

public class DataBean {
private String name;
private String occupation;
private String place;
private String country;

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

public String getName() {
return name;
}

public void setOccupation(String occupation) {
this.occupation = occupation;
}

public String getOccupation() {
return occupation;
}

public void setPlace(String place) {
this.place = place;
}

public String getPlace() {
return place;
}

public void setCountry(String country) {
this.country = country;
}

public String getCountry() {
return country;
}
}

And below is the code for the class file with business logic to generate a collection of java bean objects, which is further passed to the Jasper report engine, to generate the report:

package com.chetty.reporting.business;

import java.util.ArrayList;

import com.chetty.reporting.beans.DataBean;

public class DataBeanMaker {
public ArrayList getDataBeanList() {
ArrayList dataBeanList = new ArrayList();

//dataBeanList.add(produce("Babji, Chetty", "Engineer", "Nuremberg", "Germany"));
dataBeanList.add(produce("Albert Einstein", "Engineer", "Ulm", "Germany"));
dataBeanList.add(produce("Alfred Hitchcock", "Movie Director", "London", "UK"));
dataBeanList.add(produce("Wernher Von Braun", "Rocket Scientist", "Wyrzysk",                                               "Poland (Previously Germany)"));
dataBeanList.add(produce("Sigmund Freud", "Neurologist", "Pribor", "Czech Republic (Previously Austria)"));
dataBeanList.add(produce("Mahatma Gandhi", "Lawyer", "Gujarat", "India"));
dataBeanList.add(produce("Sachin Tendulkar", "Cricket Player", "Mumbai", "India"));
dataBeanList.add(produce("Michael Schumacher", "F1 Racer", "Cologne", "Germany"));

return dataBeanList;
}

private DataBean produce(String name, String occupation, String place, String country) {
DataBean dataBean = new DataBean();

dataBean.setName(name);
dataBean.setOccupation(occupation);
dataBean.setPlace(place);
dataBean.setCountry(country);

return dataBean;
}
}

And below is the main class file, which gets the java bean collection from the class (with business logic) and passes it to the Jasper report engine, to generate the report:

package com.chetty.reporting.engine;

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import com.chetty.reporting.beans.DataBean;
import com.chetty.reporting.business.DataBeanMaker;
import net.sf.jasperreports.engine.JasperCompileManager;
import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.design.JasperDesign;
import net.sf.jasperreports.engine.xml.JRXmlLoader;

public class Reporter {
@SuppressWarnings("unchecked")
public static void main(String[] args) throws Exception {
InputStream inputStream = new FileInputStream ("reports/test_jasper.jrxml");

DataBeanMaker dataBeanMaker = new DataBeanMaker();
ArrayList dataBeanList = dataBeanMaker.getDataBeanList();

JRBeanCollectionDataSource beanColDataSource = new 
JRBeanCollectionDataSource(dataBeanList);

Map parameters = new HashMap();

JasperDesign jasperDesign = JRXmlLoader.load(inputStream);
JasperReport jasperReport = JasperCompileManager.compileReport(jasperDesign);
JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, parameters, beanColDataSource);
JasperExportManager.exportReportToPdfFile(jasperPrint, "c:/reports/test_jasper.pdf"); 
}
}

To design the jasper report design file, you can either use iReport or the JasperAssistant Plugin for Eclipse. I used iReport, as it has more features and options. You can find the jasper report design file here: test_jasper.jrxml

When you run the 'Reporter' class, the following pdf file is generated:

Test Jasper

You can find all the source files here: jaspertest

Seam - Load i18n Messages From Database

noreply@blogger.com (Babji Prashanth, Chetty) — Wed, 25 Feb 2009 21:51:00 +0000

In some of the JavaEE web applications, it might be a requirement for you, to load internationalization (i18n) messages from database, instead of the usual way of using 'Resource Bundles'. Seam is a pretty good and extensible framework. It provides you an option to override the built-in 'ResourceLoader' functionality and provide your custom logic. Below is the code for the Java class, which extends the Seam's 'ResourceLoader' component and loads i18n messages from the database:

@Scope(ScopeType.STATELESS)
@BypassInterceptors
@Install(precedence = Install.APPLICATION, dependencies = "org.jboss.seam.security.identity")
@Name("org.jboss.seam.core.resourceLoader")
public class DatabaseResourceLoader extends ResourceLoader {
@Override
public ResourceBundle loadBundle(String bundleName) {
return new ResourceBundle() {         
public Enumeration<String> getKeys() {
//Locale locale = org.jboss.seam.core.Locale.instance();
Users user = (Users) Component.getInstance("user");

EntityManager entityManager = (EntityManager) 
Component.getInstance("entityMgr");

List resources = entityManager.createNativeQuery("select key from 
messages where locale = '" + user.getLanguage() + "-" + 
user.getCountry() + "'").getResultList();

return Collections.enumeration(resources);
}

protected Object handleGetObject(String key) {
//Locale locale = org.jboss.seam.core.Locale.instance();
EntityManager entityManager = (EntityManager) 
Component.getInstance("entityMgr");            

Users user = (Users) Component.getInstance("user");

try {
return entityManager.createNativeQuery("select value from 
messages where locale = '" + user.getUserLanguage() + 
"' and key = '" + key + 
"'").getSingleResult();
} catch (NoResultException NRE1) {
return null;
}
}
};
}
}

This component is instantiated, only if the user is authenticated, as the annotations show that it depends on the 'Identity' component. Apart from this, in the overridden methods, I'm getting the 'User' component (which holds the logged-in user details, from database) and loading messages from database (for whatever his/her settings are).

Autoboxing In Java & Bug Patterns

noreply@blogger.com (Babji Prashanth, Chetty) — Wed, 04 Feb 2009 20:47:00 +0000

Consider the following example:

1) Some Java Bean:

public class SomeBean implements Serializable {
   private int someInt;

   public int getSomeInt() {
      return this.someInt;
   }

   public void setSomeInt(int someInt) {
      this.someInt = someInt;       
   }
}

2) And somewhere in some class (with business logic), you have this:

HashMap<String, Integer> someMap = new HashMap<String, Integer>();

...and somewhere down the line, you find a code statement like this:

someBean.setSomeInt(someMap.get("someString"));

The above code statement works fine, when there are no 'null' values. But if there is a null value for some key, it fails.....because 'AutoBoxing' throws a NullPointerException when the above code statement tries to unbox a 'null' value.

So, the immediate solution for that would be something like:

Integer someInt = someMap.get("someString");

someBeam.setSomeInt((someInt != null) ? someInt : 0);

JSF & Richfaces - Display Math On Web

noreply@blogger.com (Babji Prashanth, Chetty) — Mon, 29 Sep 2008 19:41:00 +0000

Last week, I attended an event, organized by 'Nuremberg/Nurnberg(Germany) Herbstcampus', in which, bigtime folks from the software industry (specially from the Java world) like James Gosling (Founder of Java), some core developers from the Hibernate and JSF were present.

Later, I worked on a sample JSF-Facelets-Richfaces application. Instead of creating a boring sample application, I thought of working on some interesting stuff. This application, I created deals with "How To Display Math On The Web?" and uses a 'jsmath' package, which is a open source javascript library. This library has 2 options for users to display math on web: Using 'TeX Fonts' (which can be installed on your system) or Images (which are in jsmath package). I used the first option, just to make it easier. If you want, you can download these fonts from the JSMath site.

Below is the sample facelets file of this application, which displays 'Math' expressions or equations dynamically, as you type the 'Tex Expression' as input:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:rich="http://richfaces.org/rich"
xmlns:a4j="http://richfaces.org/a4j">

<ui:composition>

<STYLE TYPE="text/css">
.math {visibility: hidden}
</STYLE>
<SCRIPT>jsMath = {Controls: {cookie: {scale: 133}}}</SCRIPT>
<SCRIPT src="jsMath/jsMath.js"></SCRIPT>

<SCRIPT>
function process() {        
jsMath.Process(document.getElementById('math'));    
}      
</SCRIPT>

<f:view>
<rich:panel>
<h:outputText value="Enter Some Math Expression: " />
<h:form>
<h:inputTextarea id="intext" value="#{mathBean.text}" style="width:400;height:100">
<a4j:support event="onkeyup" reRender="outPanel" oncomplete="process()"/>
</h:inputTextarea>          
</h:form>              
</rich:panel>

<a4j:outputPanel id="outPanel">
<DIV CLASS="math">        
<h:outputText id="outtext" value="#{mathBean.text}"/>                        
</DIV>
</a4j:outputPanel>
</f:view>
</ui:composition>
</html>

As you see (in the above code), I have a input text area, where you type your 'Tex Expression', which is rendered dynamically and displayed in the "Math" div, which should be surrounded by "a4j:outputPanel" tags, to be rendered on AJAX response. The input text area, has "a4j:support" tags, which creates a AJAX request, based on the "onkeyup" javascript event and rerenders the outputPanel, which contains the 'Math' div. There is also a "oncomplete" attribute for this tag, which calls a javascript function of jsMath package, on complete of the AJAX cycle and renders the TeX expression that you typed, into a Math expression/equation.

Below is a demo, which shows how it works:

And below is the code for 'MathBean':

package com.math;

public class MathBean {
private String text;

public void setText(String text) {
this.text = text;
}

public String getText() {
return text;
}
}

Java 6 - ArrayDeque

noreply@blogger.com (Babji Prashanth, Chetty) — Wed, 13 Aug 2008 19:08:00 +0000

Java programmers are getting rich day by day (as the new versions and other frameworks come into existence), as the Java Collections Framework is hosting a lot of different datastructures and algorithm implementations. The latest one I came across is 'ArrayDeque' from Java version 6.

ArrayDeque is an implementation of the 'Deque' interface, which is a short form for "Double Ended Queue's". Double Ended Queue's extend 'Queue' and support adding and removing elements from both ends. In a Queue, you can add from one end and remove from the other. Also, Deque's can be used as a Queue and also a 'Stack'. ArrayDeque has no capacity restrictions like some other data structures (although you can specify that in one of its constructors). ArrayDeque is not threadsafe, as other collections like HashMap, et al. If you want it thread-safe, use 'LinkedBlockingQueue', which implements the 'BlockingQueue' interface, which further extends from 'Deque' interface.

A 'Deque' can be traversed from both directions programmatically using 'iterator' and 'descendingIterator' methods. Deque is doubly linked and can be compared to 'LinkedList', which also implements a 'Deque', apart from List. In LinkedList, you can access an element randomly, by the element's index, which you cant do in Deque's. It was designed this way to make it more efficient.

This kind of datastructure, which can be operated as a 'Queue', 'Stack' and can be traversed from both ends, is pretty useful in certain scenarios. A couple of 'backtracking' and other useful algorithms can be easily implemented with this kind of 'off-the-shelf' datastructures available from the 'Java Collection Framweork'.

A couple of months/years back, I had to code my own implementation to implement some algorithms. Ofcourse, its fun and a learning experience, but with ready-made stuff like this, it saves some time for a Java developer. And ofcourse, its better and useful for any developer to know the implementation 'behind-the-scenes'. By the way, Java is getting more abstract day by day (more high-level) with all these implementations and frameworks popping up from everywhere.

Below is a trivial Java program, for testing/demonstrating the new 'ArrayDeque' class from 'Java 6 Collections Framework':

import java.util.ArrayDeque;
import java.util.Iterator;

public class ArrayDequeTest
{
public static void main(String[] args) 
{    
ArrayDeque arrDeque = new ArrayDeque();

arrDeque.add("mercedes");
arrDeque.add("porsche");
arrDeque.add("audi");

for(Iterator iter = arrDeque.iterator();iter.hasNext();) {
System.out.println(iter.next());
}

System.out.println();

arrDeque.addLast("bmw");
arrDeque.add("PORSCHE");
arrDeque.addLast("Ferrari");

for(Iterator iter = arrDeque.iterator();iter.hasNext();) {
System.out.println(iter.next());
}

System.out.println();

for(Iterator descendingIter = arrDeque.descendingIterator();descendingIter.hasNext();) {
System.out.println(descendingIter.next());
}

System.out.println();
System.out.println("First Element : " + arrDeque.getFirst());
System.out.println("Last Element : " + arrDeque.getLast());
System.out.println("Contains \"porsche\" : " + arrDeque.contains("porsche"));

arrDeque.addFirst("porsche");

System.out.println();

for(Iterator iter = arrDeque.iterator();iter.hasNext();) {
System.out.println(iter.next());
}

arrDeque.removeLastOccurrence("porsche");

System.out.println();

for(Iterator iter = arrDeque.iterator();iter.hasNext();) {
System.out.println(iter.next());
}

arrDeque.removeFirstOccurrence("porsche");
System.out.println();

for(Iterator iter = arrDeque.iterator();iter.hasNext();) {
System.out.println(iter.next());
}

System.out.println();
System.out.println("Popped Element : " + arrDeque.pop());

arrDeque.push("porsche");        
System.out.println();

for(Iterator iter = arrDeque.iterator();iter.hasNext();) {
System.out.println(iter.next());
}

System.out.println("\n Size of Array Deck : " + arrDeque.size());

System.out.println("\n Peek : " + arrDeque.peek());

System.out.println("\n Peek First : " + arrDeque.peekFirst());
System.out.println("\n Peek Last : " + arrDeque.peekLast());

System.out.println();

for(Iterator iter = arrDeque.iterator();iter.hasNext();) {
System.out.println(iter.next());
}

System.out.println("\n Poll First : " + arrDeque.pollFirst());
System.out.println("\n Poll Last : " + arrDeque.pollLast());

System.out.println();

for(Iterator iter = arrDeque.iterator();iter.hasNext();) {
System.out.println(iter.next());
}

System.out.println("\n Poll : " + arrDeque.poll());

System.out.println("\n Peek First : " + arrDeque.peekFirst());
System.out.println("\n Peek Last : " + arrDeque.peekLast());

arrDeque.offerFirst("porsche");
arrDeque.offerLast("what the heck?");

System.out.println();

for(Iterator iter = arrDeque.iterator();iter.hasNext();) {
System.out.println(iter.next());
}

System.out.println("\n Get First : " + arrDeque.getFirst());
System.out.println("\n Get Last : " + arrDeque.getLast());

System.out.println("\n Element : " + arrDeque.element());

Object[] objArray = arrDeque.toArray();
System.out.println("\n Object Array Size : " + objArray.length);

String[] strArray = (String[]) arrDeque.toArray(new String[0]);
System.out.println("\n String Array Size : " + strArray.length);

ArrayDeque arrDequeClone = arrDeque.clone();
System.out.println("Clone Size : " + arrDequeClone.size());

System.out.println("arrDeque == arrDequeClone : " + (arrDeque == arrDequeClone));

System.out.println("arrDeque.equals(arrDequeClone) : " + arrDeque.equals(arrDequeClone));
}
}

For more info, check the docs from Sun's website. I'll post some more info, if I happen to spend some more time and implement an algorithm or any other imp stuff, using this datastructure.

Dont Smack The Stack (Deal With Stack Overflow Exceptions)

noreply@blogger.com (Babji Prashanth, Chetty) — Thu, 07 Aug 2008 19:15:00 +0000

At times, Java programmers come across this scenario when they have to handle 'Stack Overflow' exception in Java. This probably and mostly happens due to some petty mistakes in the code. Stack overflow happens when all the memory that is allocated to the stack is totally used. Most of the programming languages have limited memory for the stack. So, when stack memory is totally used, it results in program crash.

Stack overflow usually happens when a recursive function is used infinitely (which is probably due to some naive coding mistake). Alternatively, it can also happen when a very large stack variable is used.

Some programming languages (specially functional programming languages like 'Scheme') use 'Tail Recursion' to avoid 'Stack Overflow' errors and to improve efficiency. In this kind of technique, the last statement/operation in a method/function is a recursive call. By this use of logic, recursions can easily be transformed to iterations and thus help in effective use of memory/data-structures.

Below are some scenario's in which this kind of java exception happens:

1) Infinite Recursion:

If you have designed java applications with interfaces or abstract classes, sometimes you might bump into situations, where in, you have overridden a method from some interface/class that you are implementing and you mistakenly called the method of the interface/class, instead of calling some other method or implementing a totally new functionality. This code would not throw any compile time errors. But, at runtime, you would be surprised to see 'Stack Overflow' exceptions. Below is one trivial example:

public interface Interface1 {
public void doSomeShit();
}

Here's a class that implements 'Interface1', overrides the method and calls the same method. This is pretty stupid coding, but there might be scenario's where you might not notice because of code complexity or due to neglect.

public class Interface1Impl implements Interface1
{
public static void main(String[] args) {
Interface1Impl i = new Interface1Impl();
i.doSomeShit();

}

public void doSomeShit() {
doSomeShit();
}
}

The above program compiles fine, but throws 'Stack Overflow' exception, at runtime.

Example 2:

public class StackOverflowDemo1
{
public static void main(String[] args) 
{
StackOverflowDemo1 sofd = new StackOverflowDemo1();
sofd.method1();
}

public void method1() {
method2();
}

public void method2() {
method1();
}
}

Example 3:

public class StackOverflowDemo2
{
public static void main(String[] args) 
{
StackOverflowDemo2 sofd = new StackOverflowDemo2();
sofd.valueOf(sofd);
}

public String valueOf(Object obj) {
return valueOf(obj);    
}
}

The above code throws 'Stack Overflow' exception, as you are doing nothing special, but overriding the 'String' objects 'valueOf' method and calling it again.

The JVM (Java Virtual Machine) uses stack to store the state of java method invocations (excluding Native methods). The state of a method is in its local variables, parameters, return value and whatever business/plain logic involved in that method. Java's programming model further splits 'Java Stack' into 'Stack frames' (which is probably a programming concept for efficiently handling the state of a method, et al things). Each and every method's state is associated with a particular stack frame. When the method completes, the stack frame is deallocated. This is how the methods parameters, local variables, return type variables are always thread safe.

If you have problems with Java stack or if you want to increase the size of Java Stack, you can use the following command:

Java - Xss Stack-Size

Replace the 'Stack-Size', with the size of memory that you need.

Thats it! Happy coding and 'Protect The Stack'! ;-) (Now, the heap's calling..huh)

Groovy - Basics

noreply@blogger.com (Babji Prashanth, Chetty) — Thu, 19 Jun 2008 23:20:00 +0000

Yesterday, I was reading a bit about scripting languages and started playing with ‘Groovy’, which is an alternative to ‘Java’. You can say that it’s a bit higher-level language than Java, as it is built on Java libraries (or classes) and provides one more abstraction layer. Groovy, which is a ‘Dynamic Language’ (dynamically typed) was built to provide a scripting language for the Java platform, along the lines of Python, Ruby and Perl. Below are some imp points:

1) The Groovy compiler can be used to generate ‘Java Bytecode’, which can be integrated with any other java module/project.

2) Most of the Java code is also a valid syntax for Groovy.

3) Groovy is dynamically typed, whereas Java is static and strongly typed. Dynamically typed languages have lesser code, but more execution time.

4) Groovy also provides special XML processing through the classes XmlParser, XmlSlurper, DOMCategory.

Apart from these, Groovy has features like ‘Dynamic Typing’, ‘Closures’ and ‘builders’. Also, it’s pretty useful for testing as it supports unit-testing and mocking out-of-the-box.
After doing a bit of reading and coding some basic scripts, I tried to code a Groovy solution for the Java code that I wrote for solving the “Google’s Billboard Puzzle” (from my other blog). It’s for calculating “Euler’s Number (e)” , which is pretty basic and simple code. Here’s the code:

BigDecimal e = new BigDecimal(1.0G)
BigDecimal temp = new BigDecimal(1.0G)

for(i in 1..100) {
temp *= i
e += new BigDecimal(”1″).divide(temp, new java.math.MathContext(10000))
}

println(”e : ” + e)
println(”length of e calculated : ” + (e+”").length())

As you can see, the ‘Groovy’ script also has ‘Java’ code in it (and is valid). Since, Groovy is a dynamically typed language, it took more time than the Java code took, to produce the solution.

Here’s one more script, which outputs the ‘hashcode’ of a string:

def str = “abc”
int hashcode = 1;
int len = str.length()

for(i in 0..(len-1)) {
hashcode = 31*hashcode + str.charAt(i)
}

println(”hashcode : ” + hashcode)

The above code is a naive approach to calculate the ‘hashcode’ and is not a cryptographically secure function. Its based on the formula “s[0] * 31n − 1 + s[1] * 31n − 2 + … + s[n − 1]“, which is actually ‘Rabin-Karp Algorithm (RK)’. One might be wondering why there in ‘31′ in that Math expression. Its because Java’s int is ‘32′ bit, in length.

Groovy can also be used to test web applications, webservices, et al. Groovy can be used to test webservices in the following way:

* Act as a normal webservice client
* Use ‘WebTest’
* Use ‘SoapUI’

Ok..I decided to code a webservice client and googled for ‘Free Publicly Available Webservices’ and found a couple of websites with publicly available webservices. I picked the CDYNE’’s ‘Profanity Filter’ webservice (which filters words that are considered profanity) and provided the WSDL url to the Groovy script. Here’s the script (minimalistic):

import groovyx.net.ws.WSClient

def proxy = new WSClient(”http://ws.cdyne.com/ProfanityWS/Profanity.asmx?wsdl”, this.class.classLoader)

def result = proxy.SimpleProfanityFilter(”You crappy bugga!”)
println(result)

For the above script to run on ‘Groovy Console’, you have to copy the ‘groovyws’ jar file into Groovy’s ‘lib’ directory.

TCPMon

noreply@blogger.com (Babji Prashanth, Chetty) — Sun, 10 Jun 2007 20:46:00 +0000

Sometime back, I happened to come across this tool, called ‘TCPMon’ and thought of giving it a try. From the name of the tool, you can imply that this tool is used to monitor the TCP messages or packets that flow across the network. On the lighter side, this tool can also be categorized under “Sniffing Tools”.

Its a very lightweight tool (written in Java) that acts as a middleman between the server and client. When I said this, you can obviously make out that this tool acts like a server (listening to port connections from the real client system), as well as client (sending/relaying the TCP packets that it received from client, to the server). This functionality seems very simple to implement and so, you can write a simple TCPMon for yourself, but there are couple of more things that you can do with ‘TCPMon’, which could be very useful when you are testing some ‘Web Applications’, ‘Webservices’ or ‘Client-Server Applications’, in general.

Below are some of the uses of ‘TCPMon’:

1) For checking/testing the TCP messages that flow between Client and Server systems.

2) ‘Resend’ option - which lets you resend any request that TCPMon got from client system (which is cached at TCPMon layer).

3) ‘Simulate Slow Connection’ - This is probably the best use of TCPMon, cause you can probably test the scenarios of ’slow connection speeds’ or ‘broken communications’.

4) TCPMon can also be setup, to act as a proxy.

Below is a schematic of how TCPMon is setup between client and server:

From blogpix

If you look at the pic, you can see that TCPMon sits in between server and client and just relays the TCP messages that it gets from the client and sends back the response to the client, if and when it receives a response from the server. This comes in handy to a developer, if he/she wants to check whats really happening and what TCP messages/packets are flowing between client and server.

I used this tool, out of my personal interest, when I was working on some client-server type application. I had this scenario, that a Client (mobile device with .Net technology) communicates with Server application (Java, Glasshfish Server,EJB, servlets, webservices, et al) and so, I wanted to check and also test the application in different ways (apart from the typical unit testing stuff). I changed the Glassfish server port (by changing the configuration in domain.xml) to 9090 (instead of 8080) and setup TCPMon as below, in the screenshot:

From blogpix

Once you configure and add the connection, TCPMon is listening to port 8080, for client connections. If you have a client, which is setup in such a way that it sends request to server on port 8080, it is transparent to you that there is TCPMon in between the server (real) and the client. Below is a screenshot of TCPMon, when it is active:

From blogpix

In the above pic, the big, bottom-left frame on TCPMon window is for displaying the ‘Requests’ received from Client and the right one for ‘Response’ received from the Server. And the rows with white background, at the top of the window show all the request-response messages/packets between the server. At the bottom of the window, you can also see the “Resend” button, which can be used to resend a particular request, thats been cached at TCPMon layer. Also, you can save those “Request-Response” messages or see them in XML form.

The functionality that was most useful for me was ‘Simulating Slow Connection Speeds’, since I was using a client (simulating mobile device client) written by me, which uses ‘Apache HttpClient’ framework. I tested with different scenarios and system passed through the tests, but gave me some ideas for tweaking up the system and also clear up some bug patterns. Here’s a screenshot, which shows how to setup the TCPMon, to simulate slow connections:

From blogpix