The command javap is class disassembler that lists all methods offered by a Java Class.

References:

Spring Web Services – Reference Documentation

Spring IN ACTION

UML Diagram created using Visual Paradigm for UML Community Edition

Any CORBA project starts with a idl file that describes the interface or service. Then, we use a tool to generate language specific client and server artifacts. The tool can be a command line executable or a Ant task.

The following idl file represents a simple attendance service.

module tracker {

	interface attendance {
		long addEmployee(in string empName);

		string removeEmployee(in long empId);

		void enterEmp(in long empId, in string empName);

		string empReport(in long empId);

	};

};

The Ant Task idl2java is contained in openorb_orb_tools-<version>.jar. So, i add the jar to the Apache Ant Classpath. The task defination class is org.openorb.compiler.taskdefs.Idl2Java. I add the task defination.

The Ant build file is a very simple one. It invokes the idl2java task with two attributes, one points to the directory which contains the idl file and another points to the directory where the generated source files are dumped.

<project>
	<property name="idlDir" value="idl">
	</property>
	<property name="srcDir" value="src">
	</property>
	<target name="idl2java_task">
		<idl2java srcdir="${idlDir}" destdir="${srcDir}" verbose="false">
		</idl2java>
	</target>
</project>

The Ant task idl2java has extensive set of options available. Check the documentation for more details.

Execute the Ant task and the build fails with the following error.

Buildfile: C:\java\myProjWorkSpace001\CORBAProj\build.xml

idl2java_task:

BUILD FAILED

java.lang.NoClassDefFoundError: org/openorb/util/launcher/CompoundClassLoader

Total time: 188 milliseconds

As per error message, a class is missing. The documentation does not mention of any additional jar that needs to be added. I decided to check more on this missing class in additional jars that accompany the OpenORB distribution. But, none of them have it. Then, i checked out in website http://www.findjar.com and found that the jar tmporb-tools-1.0-DEAD.jar had the class. The website http://www.findjar.com provided a maven link for the jar, but i got 404 error. Searched in Google and found a maven repository which had it.

I added this jar to the Ant Classpath and executed the build script again. The ant task executed successfully and the Java artifacts coresponding to the idl are generated.

C:\java\myProjWorkSpace001\CORBAProj\src>cd tracker
C:\java\myProjWorkSpace001\CORBAProj\src\tracker>ls -ltr
total 22
a-----      3444 26-Nov-109 00:33 attendanceHelper.java
a-----       531 26-Nov-109 00:33 attendanceOperations.java
a-----      1809 26-Nov-109 00:33 attendancePOATie.java
a-----      7360 26-Nov-109 00:33 _attendanceStub.java
a-----      3359 26-Nov-109 00:33 attendancePOA.java
a-----      1244 26-Nov-109 00:33 attendanceHolder.java
a-----       222 26-Nov-109 00:33 attendance.java

Next, to move ahead with implementation.

To do the same on Windows operating system, use the Process Explorer program available at http://technet.microsoft.com/en-us/sysinternals/bb896653.aspx.

Start the Process Explorer, select the process which you want to analyze and enter CTRL + L. This brings up a lower pane that displays all system resources accessed by the process including files, threads, directories, port, etc. Filter the type column and you will be able to find all currently open files used by the application.

The following image displays the list of jar files accessed by Eclipse IDE.

The command lsof -p lists all open sockets, files and pipes. By analyzing the output of the command, i was able to check all the files opened by the application and able to reason why it was open by going through the application code. This also helped me in fixing unclosed file handlers.

Try out the command and try figuring out why the files are referred to. This gives an insight to functioning of the application.

Check out the usage of the command @ following link http://sial.org/howto/debug/unix/lsof/

I have used the following Person class to be managed as Entity.

package com.entities;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Person {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    int id;
    String fName;
    String lName;
    int age;

   //the setter, getter, methods for each of the attributes, toString,   

   //hashCode,  equals and default constructor are not shown here.
}

The persistence.xml file is as follows.

<?xml version="1.0" encoding="UTF-8"?>
<persistence:persistence version="1.0"
	xmlns:persistence="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 ../../persistence_1_0.xsd ">
<persistence:persistence-unit name="simplePersistenceUnit">
<persistence:provider>org.eclipse.persistence.jpa.PersistenceProvider</persistence:provider>
<persistence:class>com.entities.Person</persistence:class>
<persistence:properties>
<persistence:property name="eclipselink.jdbc.driver" value="com.mysql.jdbc.Driver"/>
<persistence:property name="eclipselink.jdbc.url" value="jdbc:mysql://localhost:3306/default"/>
<persistence:property name="eclipselink.jdbc.user" value="root"/>
<persistence:property name="eclipselink.jdbc.password" value="developer"/>
	</persistence:properties>
	</persistence:persistence-unit>
</persistence:persistence>

The persistence.xml contains information about the database.

The DDL generation information is provided to the persistence manager via a java.util.Map object.

package com.test;

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

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import org.eclipse.persistence.config.PersistenceUnitProperties;

import org.junit.Before;
import org.junit.Test;

public class TestExampleJPA {

	EntityManager em;

	@Test
	public void testDDLGeneration() {
		Map<String, String> persistProperties = new HashMap<String, String>();
		persistProperties.put(PersistenceUnitProperties.DDL_GENERATION, "create-tables");
		persistProperties.put(PersistenceUnitProperties.DDL_GENERATION_MODE, "sql-script");
		persistProperties.put(PersistenceUnitProperties.APP_LOCATION, "C:\MyFolder\temp");
		EntityManagerFactory emf = Persistence.createEntityManagerFactory( "simplePersistenceUnit", persistProperties);
		em = emf.createEntityManager();
	}
}

I have specified the database information in the persistence.xml file and DDL generation information into a Map object and providing it at runtime when creating the EntityManagerFactory object. Both the information can be provided fully either as part of  persistence.xml or Map object. I have combined both approaches for providing configuration information to JPA.

On executing the above test case the following sql files which contains the DDL for CREATE and DROP are created in C:\MyFolder\temp folder.

References:

http://wiki.eclipse.org/EclipseLink/Examples/JPA/OutsideContainer

http://wiki.eclipse.org/Using_EclipseLink_JPA_Extensions_(ELUG)

This situation can happen when there is no global repository for the schema definitions in a company. I will explain the situation in more detail.

Consider a company XYZ with web address http://www.xyz.com. The company has two enterprise applications A and B. The application A decides to expose business function as web services. Two different teams 1 and 2 in application A are working on building the web service.

Both the team use the same target namespace http://www.xyz.org/appA/.

Team 1 builds an web service WS-1. They create a element NewOperation.

The schema of the element NewOperation and part of the wsdl definition is listed below

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<wsdl:definitions xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://www.xyz.org/appA/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="NewWSDLFile" targetNamespace="http://www.xyz.org/appA/">
  <wsdl:types>
    <xsd:schema targetNamespace="http://www.xyz.org/appA/">
      <xsd:element name="NewOperation">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="in" type="xsd:string"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
   </wsdl:types>

Team 2 also builds an web service WS-2. They also create a element NewOperation.

The schema of the element NewOperation and part of the wsdl definition is listed below

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<wsdl:definitions xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://www.xyz.org/appA/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="NewWSDLFile" targetNamespace="http://www.xyz.org/appA/">
  <wsdl:types>
    <xsd:schema targetNamespace="http://www.xyz.org/appA/">
      <xsd:element name="NewOperation">
        <xsd:complexType>
          <xsd:sequence>
              <xsd:element name="in" type="xsd:string" />
              <xsd:element name="in_1" type="xsd:string"></xsd:element>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
   </wsdl:types>

As you can see both the elements have the same name, but have different structure which is an not a good design. Since, both the team do not interact with other, they have failed to identify the flaw. Both, the team build server implementation of their web service and deploy each as EAR independent of the other. Both the teams do not face any issue, since both the server implementations are deployed independently.

Now, team in application B decides to use the web services provided by application A. They build client implementations for both the web services provided by A using standard build tools (clientgen from Weblogic). The build tools usually generate the java files (in a jar) binding the schema elements to classes created in the reverse namespace package (i.e., org.xyz.www.appA). They put the client jars of both the web service in the same classpath of the application B.

When they try to use the operations provided by the web service, they face exception related to serialization or deserialization whenever an operation involving the element NewOperation is involved. The exception can happen in either the WS-1 or WS-2 web service. This is because, a wrong class is used in the web service. As per java classpath rule, whenever NewOperation class needs to be loaded it finds only one version of the class depending on which client jar appears first. The other NewOperation class is never found by the application.

In order to resolve the issue, the team A needs to move the definition of the element NewOperation in one of the web service to a different target namespace. But this is a costly option, since WS-1 and WS-2 are already implemented and will require changes in the server implementation and also for all the clients using the web service.

The other option is for the client to use options provided in the build tools to generate class binding the schema definition in different package other than that generated by default for one of the web service.

This can done in Weblogic tool clientgen by adding the option typePackageName. Note the additional attribute typePackageName in the ant build script.

<clientgen wsdl="http://example.com/myapp/myservice.wsdl"
           packageName="myapp.myservice.client"
           clientJar="myapps/myService_client.jar"
       typePackageName="com.appB"
/>

Also the same can be done in Eclipse by checking the “Define custom mapping for namespace to package” option and defining the custom mapping when generating the client implementation of the web service.

This avoids the clash as the client implementations are generated under different package.

This problem needs to be avoided in first place when creating the web service. Each company needs to have a central repository where all the schema definitions are available to avoid duplication of element name under same target namespace.

	public static String getMySqlStatement(ArrayList<String> dataValues) {
		if ((dataValues == null) || (dataValues.size() == 0)) {
			throw new IllegalArgumentException();
		}
		StringBuilder sql = new StringBuilder ("SELECT * FROM MY_TABLE WHERE MY_COLUMN IN (");
		StringBuilder colValues = new StringBuilder();
		for (String data: dataValues) {
			colValues.append("'").append(data).append("',");
		}
		//Remove the trailing comma(,) and add the final braces
		sql.append(colValues.substring(0, (colValues.length()-1))).append(")");
		return sql.toString();
	}

The method builds an Select query using the elements in the arraylist dataValues in the IN clause.
The SQL returned by the method executes normally when the size of dataValues is less then or equal to 1000. But, when the size of dataValues is greater than 1000, the SQL throws an exception.

This is because there is a limit on the number of parameters in the IN Clause. For Oracle 9i, the limit is 1000. The limit can vary based on database.

Hence, the above method does not work in all cases. It is required to build SQL queries based on the size of the parameters in the IN clause like breaking up into multiple SQL statements and then combining the results. The above method is modified to return multiple SQL statements if the number of parameters is greater than the limit(in this case 1000).

    public static ArrayList getMySqlStatements(ArrayList dataValues) {
        if ((dataValues == null) || (dataValues.size() == 0)) {
            throw new IllegalArgumentException();
        }
        final int IN_PARAMETER_LIMIT = 1000;
        ArrayList sqlStatements = new ArrayList();
        StringBuilder sql = new StringBuilder (“SELECT * FROM MY_TABLE WHERE MY_COLUMN IN (“);
        StringBuilder colValues = null;
        for (int i=0, j=0, length= dataValues.size(); i < length; i++) {             if (colValues == null) {                 colValues = new StringBuilder();             }             j++;             String data = dataValues.get(i);             colValues.append("'").append(data).append("',");             if (j == IN_PARAMETER_LIMIT) {                 sqlStatements.add((sql.append(colValues.substring(0, (colValues.length()-1))).append(")")).toString());                 j=0;                 colValues = null;             }         }         return sqlStatements;     } [/sourcecode] This error may not show up in normal circumstances unless the number of parameters is greater than 1000. To find bugs due to software limits, it is always required to unit test under maximum load conditions.

The following code shows how the Java Reflection API’s can be used to retrieving information. The

public static void exploreObject(Object obj, PrintStream ps)

method takes an Object argument and analyzes it. It displays the class name, the interfaces the class extends, the superclass, the attributes and it’s datatype and the list of all methods complete with their signature.

Also, a sample usage is shown passing an instance of String object.

package com.explore;

import java.io.PrintStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class ClassExplorer {

    public static void main(String[] args) {
        exploreObject(new String(), System.out);
    }

    public static void exploreObject(Object obj, PrintStream ps) {
        StringBuilder sb = new StringBuilder();
        sb.append("CLASS NAME").append('\n');
        sb.append(obj.getClass().getName()).append('\n');
        sb.append("#####################################################################").append('\n');
        Class<?>[] interfaces = obj.getClass().getInterfaces();
        if (interfaces.length != 0) {
            sb.append("INTERFACES").append('\n');
            for (Class<?> i: interfaces)
                sb.append(i.getName()).append('\n');
            sb.append("#####################################################################").append('\n');
        }
        Class<?> superClass = obj.getClass().getSuperclass();
        if (superClass != null) {
            sb.append("SUPERCLASS").append('\n');
            sb.append(superClass.getName()).append('\n');
            sb.append("#####################################################################").append('\n');
        }
        sb.append("ATTRIBUTES").append('\n');
        //Get the attributes
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field f: fields) {
            if (f.getType().getComponentType() != null) {
                sb.append(f.getType().getComponentType().getName()).append("[]").append('\t').append(f.getName()).append('\n');
            }
            else {
                sb.append(f.getType().getName()).append('\t').append(f.getName()).append('\n');
            }
        }
        sb.append("#####################################################################").append('\n');
        sb.append("METHODS").append('\n');
        //Get all methods
        Method[] methods = obj.getClass().getDeclaredMethods();
        for (Method m: methods) {
            //Get the modifier
            sb.append(Modifier.toString(m.getModifiers())).append(" ");
            //Get the return type of the method
            if (m.getReturnType().getComponentType() != null) {
                sb.append(m.getReturnType().getComponentType().getName()).append("[] ");
            } else {
                sb.append(m.getReturnType().getName()).append(" ");
            }
            //Get the method name
            sb.append(m.getName()).append("(");
            //Get the parameter list
            Class<?>[] parameters = m.getParameterTypes();
            if (parameters.length != 0) {
                StringBuilder parameterList = new StringBuilder();
                for (Class<?> p: parameters) {
                    if (p.getComponentType() != null) {
                        parameterList.append(p.getComponentType().getName()).append("[], ");
                    } else {
                        parameterList.append(p.getName()).append(", ");
                    }
                }
                sb.append(parameterList.substring(0, parameterList.length()-2));
            }
            sb.append(")");
            //Get the exceptions
            Class<?>[] exceptions = m.getExceptionTypes();
            if (exceptions.length != 0) {
                StringBuilder exceptionList = new StringBuilder();
                sb.append(" throws ");
                for (Class<?> e: exceptions)
                    exceptionList.append(e.getName()).append(", ");
                sb.append(exceptionList.substring(0, (exceptionList.length() - 2)));
            }
            sb.append(";").append('\n');
        }    

        //Print to the stream
        ps.print(sb.toString());
    }

}

On executing the above class, the output is

CLASS NAME
java.lang.String
#####################################################################
INTERFACES
java.io.Serializable
java.lang.Comparable
java.lang.CharSequence
#####################################################################
SUPERCLASS
java.lang.Object
#####################################################################
ATTRIBUTES
char[]    value
int    offset
int    count
int    hash
long    serialVersionUID
java.io.ObjectStreamField[]    serialPersistentFields
java.util.Comparator    CASE_INSENSITIVE_ORDER
#####################################################################
METHODS
public int hashCode();
public volatile int compareTo(java.lang.Object);
public int compareTo(java.lang.String);
public int indexOf(java.lang.String, int);
static int indexOf(char[], int, int, char[], int, int, int);
public int indexOf(java.lang.String);
public int indexOf(int);
public int indexOf(int, int);
public boolean equals(java.lang.Object);
public java.lang.String toString();
public char charAt(int);
private static void checkBounds(byte[], int, int);
public int codePointAt(int);
public int codePointBefore(int);
public int codePointCount(int, int);
public int compareToIgnoreCase(java.lang.String);
public java.lang.String concat(java.lang.String);
public boolean contains(java.lang.CharSequence);
public boolean contentEquals(java.lang.StringBuffer);
public boolean contentEquals(java.lang.CharSequence);
public static java.lang.String copyValueOf(char[], int, int);
public static java.lang.String copyValueOf(char[]);
public boolean endsWith(java.lang.String);
public boolean equalsIgnoreCase(java.lang.String);
public static transient java.lang.String format(java.lang.String, java.lang.Object[]);
public static transient java.lang.String format(java.util.Locale, java.lang.String, java.lang.Object[]);
public byte[] getBytes(java.nio.charset.Charset);
public byte[] getBytes();
public byte[] getBytes(java.lang.String) throws java.io.UnsupportedEncodingException;
public void getBytes(int, int, byte[], int);
public void getChars(int, int, char[], int);
void getChars(char[], int);
public native java.lang.String intern();
public boolean isEmpty();
public int lastIndexOf(java.lang.String);
public int lastIndexOf(int);
public int lastIndexOf(int, int);
static int lastIndexOf(char[], int, int, char[], int, int, int);
public int lastIndexOf(java.lang.String, int);
public int length();
public boolean matches(java.lang.String);
public int offsetByCodePoints(int, int);
public boolean regionMatches(int, java.lang.String, int, int);
public boolean regionMatches(boolean, int, java.lang.String, int, int);
public java.lang.String replace(char, char);
public java.lang.String replace(java.lang.CharSequence, java.lang.CharSequence);
public java.lang.String replaceAll(java.lang.String, java.lang.String);
public java.lang.String replaceFirst(java.lang.String, java.lang.String);
public java.lang.String[] split(java.lang.String, int);
public java.lang.String[] split(java.lang.String);
public boolean startsWith(java.lang.String, int);
public boolean startsWith(java.lang.String);
public java.lang.CharSequence subSequence(int, int);
public java.lang.String substring(int);
public java.lang.String substring(int, int);
public char[] toCharArray();
public java.lang.String toLowerCase();
public java.lang.String toLowerCase(java.util.Locale);
public java.lang.String toUpperCase();
public java.lang.String toUpperCase(java.util.Locale);
public java.lang.String trim();
public static java.lang.String valueOf(char[]);
public static java.lang.String valueOf(int);
public static java.lang.String valueOf(long);
public static java.lang.String valueOf(float);
public static java.lang.String valueOf(double);
public static java.lang.String valueOf(java.lang.Object);
public static java.lang.String valueOf(char);
public static java.lang.String valueOf(char[], int, int);
public static java.lang.String valueOf(boolean);

There are lot of API’s in the Java Reflection package to support more operations. These API’s can be used to analyse objects dynamically.

TCP/IP Monitor is a proxy server that monitors for all traffic flowing through. In case, you want to monitor the traffic between two network nodes, you will have to use TCP/IP Monitor as proxy server so that it can monitor the traffic flowing between the endpoints.

Initially setup the TCP/IP Monitor using Preferences window in Eclipse. Create a new monitor by specifying the local monitoring port(which will the port number of the TCP/IP Monitor proxy server), host name(host name of the webservice server), port(port number of the webservice server port) and type(select HTTP or TCP/IP). After the new monitor is defined start the monitor.

Modify the Weblogic webservice client code to use the TCP/IP Monitor proxy server. This is done by the following piece of code. This code needs to be executed before client webservice port creation.

        System.setProperty("http.proxyHost", "localhost");
        System.setProperty("http.proxyPort", "80");
        System.setProperty("weblogic.webservice.transport.http.proxy.host", "localhost");
        System.setProperty("weblogic.webservice.transport.http.proxy.port", "80");

The port specified will have to be same as the one of the TCP/IP Monitor created to monitor the webservice.

On invocation of the webservice client, you will be able to see the data exchanged between the client and the server in the TCP/IP Monitor view. It shows the SOAP messages exchanged.

TCP/IP Monitor is an excellent tool to analyze the SOAP messages exchanged in webservice invocations.

The TCP/IP Monitor plugin is part of standard Eclipse distribution for J2EE developers.

Useful Links

To search documentation on TCP/IP Monitor

http://help.eclipse.org/ganymede/index.jsp

Using proxy for Weblogic webservice client

http://edocs.bea.com/wls/docs81/webserv/client.html#1077879

Just decided to share it.

import java.util.Scanner;

public class CompareVersion {

    final static int LESSER = -1;        //versionA is lesser than versionB
    final static int EQUALS = 0;        //versionA equal to versionB
    final static int GREATER = 1;        //versionA is greater then versionB

    public static int compareVersions(String versionA, String versionB) {
        Scanner a = (new Scanner(versionA)).useDelimiter(“\\.”);
        Scanner b = (new Scanner(versionB)).useDelimiter(“\\.”);
        int i, j;
        while (a.hasNext() && b.hasNext()) {
            i = Integer.parseInt(a.next());
            j = Integer.parseInt(b.next());
            if (i > j) {
                return CompareVersion.GREATER;
            } else if ( i < j) {                 return CompareVersion.LESSER;             }         }         if (a.hasNext() && !b.hasNext()) { return CompareVersion.GREATER; } else if (!a.hasNext() && b.hasNext()) { return CompareVersion.LESSER; } else { return CompareVersion.EQUALS; }     } } [/sourcecode]

Sample Usage Scenarios..

The code snippet can be included as part of a larger toolset to compare versions in different environments.

The code confirms to Java 1.4
The code uses the class java.util.Scanner and this this class is available in Java Version 5 and above. Hence, the code works only with Java 5 and above. Also, the code has been updated. The previous code missed an scenario.

I have rewritten the code for Java 1.4. I have used String manipulation method instead of using java.util.Scanner. The code is as follows.

public class CompareVersion {

final static int LESSER = -1; // versionA is lesser than versionB
final static int EQUALS = 0; // versionA equal to versionB
final static int GREATER = 1; // versionA is greater then versionB

public static int compareVersions(String versionA, String versionB) {
String[] a = versionA.split(“\\.”);
String[] b = versionB.split(“\\.”);
int i, j;
int index = 0;
while ((index < a.length) && (index < b.length)) { i = Integer.parseInt(a[index]); j = Integer.parseInt(b[index]); if (i > j) {
return CompareVersion.GREATER;
} else if (i < j) { return CompareVersion.LESSER; } index++; } if ((index < a.length) && (index == b.length)) { return CompareVersion.GREATER; } else if ((index == a.length) && (index < b.length)) { return CompareVersion.LESSER; } else { return CompareVersion.EQUALS; } } } [/sourcecode]

This blog is about how to track various usage scenario in Java from code perspective.

The stack trace provides an excellent way to track the code flow. You would have seen in stack trace logs when exceptions are thrown, the stack trace has detail information on the classes, methods and the line numbers. We will use the same approach to trace the code flow without waiting for exceptions to happen.

In this scenario, we create a Throwable object, which the parent class of Exception. The Throwable object contains the entire stackTrace at the point where the object is created. We can use the getStackTrace() method on the Throwable object to obtain the stackTrace. The method returns an array of StackTraceElement. Each StackTraceElement represent a single stack frame and has information regarding the method which was invoked in the execution sequence. Also, the java class file name, complete java class name and the line number of invocation is also present.

Consider the following simple code scenario.

public String getName() {
          return "SOL_APP_MANG";
}

Inorder to trace, how the method getName is used in a application, the method is modified as follows.

public String getName() {
          Throwable throwable = new Throwable();
          StackTraceElement[] stElements = throwable.getStackTrace();
          for (StackTraceElement ste: stElement)
                   system.out.println("File Name:" + ste.getFileName());
                   system.out.println("Class Name:" + ste.getClassName());
                   system.out.println("Method Name:" + ste.getMethodName());
                   system.out.println("Line number:" + ste.getLineNumber());
          return "SOL_APP_MANG";
}

The code is very straightforword and simple.

I have implemented a small library for analyzing the stackTrace of the Throwable object. The library is a very small jar file with size of just 6.5 kb. The UML diagram is shown below.

It consists of 2 classes and a interface. The interface IDisplayableStackTrace has the method

public String getDisplayedStackTrace(StackTraceElement st)

Every implementation of the IDisplayableStackTrace should implement the method and implement the functionality of how a StackTraceElement should be represented as a String.

This allows any implmentation to be plugged based on requirement.

The following SimpleDisplayableStackTrace is an implementation.

package com.ast.sampleExample;

import com.ast.analyse.IDisplayableStackTrace;

public class SimpleDisplayableStackTrace implements IDisplayableStackTrace {

    @Override
    public String getDisplayedStackTrace(StackTraceElement st) {
        StringBuilder sb = new StringBuilder();
        sb.append(":$FILE$:").append(st.getFileName())
          .append(":$CLASS$:").append(st.getClassName())
          .append(":$METHOD$:").append(st.getMethodName())
          .append(":$LINE$:").append(st.getLineNumber());
        return sb.toString();
    }
}

You can write your own implementation of IDisplayableStackTrace depending on requirement.

The AnalyseThrowable class is the single most important class of the library. The AnalyseThrowable class has a static method.

public static void dumpStackTrace(IDisplayableStackTrace dst, PrintStream pw, Throwable throwable)
            throws AnalyseThrowableException

This method has the following arguments.

• IDisplayableStackTrace dst – An implementation of the class IDisplayableStackTrace
• PrintStream pw – A PrintStream object to where the customized stack trace needs to be written
• Throwable throwable – A Throwable whose stack trace needs to be analysed

Also, the class provides the method

public void dumpStackTrace(Throwable throwable) throws AnalyseThrowableException

which can be invoked using an instanceof AnalyseThrowable. The AnalyseThrowable has a parameterized constructor which accepts an implementation of IDisplayableStackTrace and PrintStream.

One of the variations of the dumpStackTrace method can be used depending on the scenario.

The class AnalyseThrowableException extends Exception class and some of the methods of class
AnalyseThrowable throws the AnalyseThrowableException exception object which needs to be
handled by the client using the library.

A typical usage scenario of the library is given below.

public String getName() {
          try {
                AnalyseThrowable.dumpStackTrace(new SimpleDisplayableStackTrace(), System.out, new Throwable());
          }
          catch(AnalyseThrowableException ex) {
                ex.printStackTrace(System.out);
          }
          return "SOL_APP_MANG";
}

An sample stack trace, when executed through a junit test case is shown below.

:$FILE$:AnalyseThrowableTest.java:$CLASS$:com.ast.analyse.AnalyseThrowableTest:$METHOD$:testDumpStackTraceIDisplayableStackTracePrintStreamThrowable:$LINE$:13
:$FILE$:NativeMethodAccessorImpl.java:$CLASS$:sun.reflect.NativeMethodAccessorImpl:$METHOD$:invoke0:$LINE$:-2
:$FILE$:NativeMethodAccessorImpl.java:$CLASS$:sun.reflect.NativeMethodAccessorImpl:$METHOD$:invoke:$LINE$:39
:$FILE$:DelegatingMethodAccessorImpl.java:$CLASS$:sun.reflect.DelegatingMethodAccessorImpl:$METHOD$:invoke:$LINE$:25
:$FILE$:Method.java:$CLASS$:java.lang.reflect.Method:$METHOD$:invoke:$LINE$:597
:$FILE$:TestMethodRunner.java:$CLASS$:org.junit.internal.runners.TestMethodRunner:$METHOD$:executeMethodBody:$LINE$:99
:$FILE$:TestMethodRunner.java:$CLASS$:org.junit.internal.runners.TestMethodRunner:$METHOD$:runUnprotected:$LINE$:81
:$FILE$:BeforeAndAfterRunner.java:$CLASS$:org.junit.internal.runners.BeforeAndAfterRunner:$METHOD$:runProtected:$LINE$:34
:$FILE$:TestMethodRunner.java:$CLASS$:org.junit.internal.runners.TestMethodRunner:$METHOD$:runMethod:$LINE$:75
:$FILE$:TestMethodRunner.java:$CLASS$:org.junit.internal.runners.TestMethodRunner:$METHOD$:run:$LINE$:45
:$FILE$:TestClassMethodsRunner.java:$CLASS$:org.junit.internal.runners.TestClassMethodsRunner:$METHOD$:invokeTestMethod:$LINE$:66
:$FILE$:TestClassMethodsRunner.java:$CLASS$:org.junit.internal.runners.TestClassMethodsRunner:$METHOD$:run:$LINE$:35
:$FILE$:TestClassRunner.java:$CLASS$:org.junit.internal.runners.TestClassRunner$1:$METHOD$:runUnprotected:$LINE$:42
:$FILE$:BeforeAndAfterRunner.java:$CLASS$:org.junit.internal.runners.BeforeAndAfterRunner:$METHOD$:runProtected:$LINE$:34
:$FILE$:TestClassRunner.java:$CLASS$:org.junit.internal.runners.TestClassRunner:$METHOD$:run:$LINE$:52
:$FILE$:JUnit4TestReference.java:$CLASS$:org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference:$METHOD$:run:$LINE$:38
:$FILE$:TestExecution.java:$CLASS$:org.eclipse.jdt.internal.junit.runner.TestExecution:$METHOD$:run:$LINE$:38
:$FILE$:RemoteTestRunner.java:$CLASS$:org.eclipse.jdt.internal.junit.runner.RemoteTestRunner:$METHOD$:runTests:$LINE$:460
:$FILE$:RemoteTestRunner.java:$CLASS$:org.eclipse.jdt.internal.junit.runner.RemoteTestRunner:$METHOD$:runTests:$LINE$:673
:$FILE$:RemoteTestRunner.java:$CLASS$:org.eclipse.jdt.internal.junit.runner.RemoteTestRunner:$METHOD$:run:$LINE$:386
:$FILE$:RemoteTestRunner.java:$CLASS$:org.eclipse.jdt.internal.junit.runner.RemoteTestRunner:$METHOD$:main:$LINE$:196

Download jar file

OR

Download jar file

<?xml version="1.0" encoding="UTF-8"?>
<tns:classList xmlns:tns="http://www.example.org/NewXMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.example.org/NewXMLSchema ../xsds/NewXMLSchema.xsd ">
  <tns:comment>Java Bean Class of the MyProject project</tns:comment>
  <tns:class>
    <tns:import></tns:import>
    <tns:package>com.myProject</tns:package>
    <tns:name>Person</tns:name>
    <tns:interface>java.io.Serializable</tns:interface>
    <tns:inherits></tns:inherits>
    <tns:variables>
      <tns:type>String</tns:type>
      <tns:name>fname</tns:name>
    </tns:variables>
    <tns:variables>
        <tns:type>String</tns:type>
        <tns:name>lname</tns:name>
    </tns:variables>
    <tns:variables>
        <tns:type>int</tns:type>
        <tns:name>age</tns:name>
    </tns:variables>
    <tns:variables>
        <tns:type>String</tns:type>
        <tns:name>nationality</tns:name>
    </tns:variables>
    <tns:variables>
        <tns:type>String</tns:type>
        <tns:name>sex</tns:name>
    </tns:variables>
  </tns:class>
</tns:classList>

Now, we use the tool xml2javabean.jar to generate the java bean source files.
java -jar xml2javabean.jar test.xml

The following is the java bean source file generated.

/**
 * Java Bean Class of the MyProject project
 * Java Bean File created @ 30-03-2008 10:50:03.656
 */

package com.myProject;

public class Person implements java.io.Serializable {
     private String fname;
     private String lname;
     private int age;
     private String nationality;
     private String sex;

     // Default Constructor
     public Person() {
         super();
         fname = new String();
         lname = new String();
         age = 0;
         nationality = new String();
         sex = new String();
     }

     //parameterized Constructor
     public Person(
         String fname ,
         String lname ,
         int age ,
         String nationality ,
         String sex) {
         super();
         this.fname = fname;
         this.lname = lname;
         this.age = age;
         this.nationality = nationality;
         this.sex = sex;
     } 

     public void setFname(String fname) {
         this.fname = fname;
     }

     public String getFname() {
         return fname;
     }

     public void setLname(String lname) {
         this.lname = lname;
     }

     public String getLname() {
         return lname;
     }

     public void setAge(int age) {
         this.age = age;
     }

     public int getAge() {
         return age;
     }

     public void setNationality(String nationality) {
         this.nationality = nationality;
     }

     public String getNationality() {
         return nationality;
     }

     public void setSex(String sex) {
         this.sex = sex;
     }

     public String getSex() {
         return sex;
     }

     public boolean equals(Object obj) {
         if (this == obj)
             return true;
         if (obj == null)
             return false;
         if (getClass() != obj.getClass())
             return false;
         final Person other = (Person)obj;
         if (fname == null) {
             if (other.fname != null)
                 return false;
         } else if (!fname.equals(other.fname))
             return false;
         if (lname == null) {
             if (other.lname != null)
                 return false;
         } else if (!lname.equals(other.lname))
             return false;
         if (age != other.age)
             return false;
         if (nationality == null) {
             if (other.nationality != null)
                 return false;
         } else if (!nationality.equals(other.nationality))
             return false;
         if (sex == null) {
             if (other.sex != null)
                 return false;
         } else if (!sex.equals(other.sex))
             return false;
         return true;
     } 

     public int hashCode() {
         final int prime = 31;
         int result = 1;
         result = prime * result + ((fname == null)?0:fname.hashCode());
         result = prime * result + ((lname == null)?0:lname.hashCode());
         result = prime * result + age;
         result = prime * result + ((nationality == null)?0:nationality.hashCode());
         result = prime * result + ((sex == null)?0:sex.hashCode());
         return result;
     }

     public String toString() {
         StringBuilder s = new StringBuilder();
         s.append("<class name=\"Person\">");
         s.append("<fname>").append(fname.toString()).append("</fname>");
         s.append("<lname>").append(lname.toString()).append("</lname>");
         s.append("<age>").append(age).append("</age>");
         s.append("<nationality>").append(nationality.toString()).append("</nationality>");
         s.append("<sex>").append(sex.toString()).append("</sex>");
         s.append("</class>");
         return s.toString();
     }
}

The above approach of java bean source file generation can be extended to other languages as well.
Well, this blog is about use of a tool to generate java beans from language independent xml language.I have chosen java beans for the code generation. This is because java beans have a standard behavior that is well explained in Java Documentation. Also, in any web applications and enterprise applications, the most important objects, the domain objects are defined as java beans. The behavior and the implementation of domain objects will be well defined and will be same for the hundreds of domain objects in any application. Hence, instead of developing the domain objects by developers, it is advisable to generate the domain objects using some code generation tool. The tool, which i have mentioned helps in this task.The following diagram gives an complete generalized overview of the entire process.

The tool, which i have developed is for Java platform. Also, several assumptions were made before the development of the tool.

The  initial step in this process is about developing a xsd that specifies the structure of the xml. As, you can see from the xsd diagram, the main element is classList, which encompasses any number of class element and comment element. The comment element is of String type and specified the comments that should be included in the Source file of the generated java beans. The class element has import,package, name, interface, inherits and variables elements, which represents the structure of the class in java. Except variables, all other sub-elements of the class element are of type String. The sub-element variables is of element Variable which represents the attributes of a java class.

The xsd document corresponding the above diagram.

<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
    targetNamespace="http://www.example.org/NewXMLSchema"
    xmlns:tns="http://www.example.org/NewXMLSchema"
    elementFormDefault="qualified">

    <complexType name="variable">
        <sequence>
            <element name="type" type="string" maxOccurs="1"
                minOccurs="1">
            </element>
            <element name="name" type="string" maxOccurs="1"
                minOccurs="1">
            </element>
        </sequence>
    </complexType>

    <complexType name="class">
        <sequence>
            <element name="import" type="string" maxOccurs="unbounded"
                minOccurs="0">
            </element>
            <element name="package" type="string" maxOccurs="1"
                minOccurs="0">
            </element>
            <element name="name" type="string" maxOccurs="1"
                minOccurs="1">
            </element>
            <element name="interface" type="string"
                maxOccurs="unbounded" minOccurs="0">
            </element>
            <element name="inherits" type="string" maxOccurs="1"
                minOccurs="0">
            </element>
            <element name="variables" type="tns:variable"
                maxOccurs="unbounded" minOccurs="0">
            </element>
        </sequence>
    </complexType>

    <complexType name="classList">
        <sequence>
            <element name="comment" type="string" maxOccurs="unbounded"
                minOccurs="0">
            </element>
            <element name="class" type="tns:class" maxOccurs="unbounded"
                minOccurs="0">
            </element>
        </sequence>
    </complexType>

    <element name="classList" type="tns:classList"></element>
</schema>

Some of the assumptions made are

• The comment element is common for all the generated java bean source files
• There is no verification of imports, interfaces, extension and data type of variable
• Interfaces are assumed to be of marker interface
• No abstract classes to extend
• The datatype mentioned in the xml is checked with the list of primitive datatype list in the tool. If it is not found, then the data type is assumed to be user defined datatype

The tool has been developed to generate the java bean source code as per the following assumptions.

• Setter and getter methods for all attributes of the class
• equals and hashcode implementation
• toString implementation

Now, i will provide a slight overview of the design and development of the tool.

The input for the tool is xml and it verifies the xml against the xsd, i have JAXB for dealing with xml data. JAXB provides easy way to represent the xml document as java objects, easing dealing with xml data. I have used XJC eclipse plugin to generate the java classes corresponding the elements in the xsd. The following class diagrams represents the java classes generated by the XJC plugin.

The object representation of the xml document can be obtained using an instance of javax.xml.bind.Unmarshaller class. This object parses the xml document and creates instances of the xsd binding objects. The next step involves generating the java bean source files using the objects, which represent the xml.

The following class diagram represents the classes, which does the actual work of generating the java bean source files from the xml. The CreateJavaBeans class has methods, which builds the java bean source file part by part. The Xml2JavaBean acts as the master. Xml2Obj class transforms the xml document to objects.

This tool may not meet the requirements for all cases. But, the tool can be enhanced to generate the java bean source files as per requirement. All, the classes are packed together in the xml2javabean.jar. The source code is available for download without any license or terms.The implementation of the methods of the class CreateJavaBeans can be changed to generate different implementation of the generated java beans.

Usage

Create a xml document, which confirms to the xsd document in the downloads section.

Generate the java bean source files using the following command

java -jar xml2javabean.jar <xml-file>

OR

java -jar xml2javabean.jar <xml-file> <directory-path>

<directory-path> is optional. The <directory-path> specifies the directory where the java   files are to be generated.

Advantages of using this approach

• A single xml file that represents the entire domain objects
• Better version control management
• Domain object’s language representation(ex: javabeans) confirm to standard specification(you decide)
• Better control over domain objects
• Easier and faster domain object generation
• Can be integrated with build tool (as an task in Ant build script) for generation of java bean source files during code build
• Language independent domain object representation (xml) provides easier option, when migrating to different language and platform
• xml2javabean.jar which is the xml to java bean conversion engine can be replaced with engines(for generation of domain objects in other language), thereby providing plugin model for the whole approach

Final Picture
The tool can be integrated as part of a much larger tool, which provides graphical domain objects modeling, with verification of the datatypes of attributes, interfaces, inheritance, imports etc, using xml as persistent layer and plugins to generate the domain objects in any languages. And this imaginary tools seems to be like UML tool with reverse engineering option for many languages.

The tool is just the demonstration of the concept outlined above.

I have learnt a lot in the development of this tool. I will continue to enhance the tool further.

Downloads

XSD document

Source Code

Jar file enclosed in zip

Class diagram of the tool

I have used the “National Register of Historic Places” data which was available at site http://www.itasoftware.com/careers/SolveThisWorkHerePuzzles.html?catid=114
The data file is an xml file and has around 84000 addresses. Each address is represented as a Property object.

The address data is indexed using the Open Source search engine Apache Lucene. The xml file is loaded into memory using the JAXB API’s.

In order to use JAXB, we will need schema to generate classes corresponding to the each Property xml data. I have generated schema for the xml file using trang jar.

Command for generating the schema for the xml document.

java -jar trang.jar -I xml -O xsd nrhp.xml nrhp.xsd

The xsd document is as follows.

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:element name="properties">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="property"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:element name="property">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="name"/>
        <xs:element minOccurs="0" ref="address"/>
        <xs:element minOccurs="0" ref="city"/>
        <xs:element ref="state"/>
      </xs:sequence>
      <xs:attribute name="id" use="required" type="xs:integer"/>
    </xs:complexType>
  </xs:element>
  <xs:element name="name" type="xs:string"/>
  <xs:element name="address" type="xs:string"/>
  <xs:element name="city" type="xs:string"/>
  <xs:element name="state" type="xs:NCName"/>
</xs:schema>

Next, the schema needs to be binded., generating a set of java classes that represent the schema.This can be done using the xjc command from commandline or using the xjc eclipse plugin. The following classes are generated.

com.objects.ObjectFactory.java
    com.objects.Properties.java
    com.objects.Property.java

In most of the cases, the schema binding classes will be READ ONLY. But, we can modify the classes under careful consideration. I have modifed the class com.objects.Properties.java to include the following method.

public void setProperty(List<Property> prop) {
        property = prop;
    }

which, is used when returing the results from server to web browser.I have created two classes, com.dataConversion.Xml2Obj to convert xml document to java objects and com.dataConversion.Obj2Xml to
convert java objects back to XML document. With JAXB, both the tasks can be easily implemented.Class com.dataConversion.Xml2Obj

package com.dataConversion;

import java.io.File;
import java.util.List;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;

public class Xml2Obj {
    public List<com.objects.Property> getAddressList(String xmlFilePath) throws JAXBException {
        JAXBContext jc = JAXBContext.newInstance("com.objects");
        Unmarshaller unmarshaller = jc.createUnmarshaller();
        com.objects.Properties properties =
            (com.objects.Properties)unmarshaller.unmarshal(new File(xmlFilePath));
        return properties.getProperty();
    }
}

Class com.dataConversion.Obj2Xml

package com.dataConversion;

import java.io.Writer;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;

public class Obj2Xml {
    public void persistAddressList(com.objects.Properties prop, Writer writer) throws JAXBException {
        JAXBContext jaxbContext = JAXBContext.newInstance("com.objects");
        Marshaller marshaller = jaxbContext.createMarshaller();
        marshaller.marshal(prop, writer);
    }
}

The most important process is indexing the data. The address data is indexed on address and city field together. Since, i am storing the index in memory for performance, i have used org.apache.lucene.store.RAMDirectory to store the index. The indexing process involves org.apache.lucene.index.IndexWriter object, adding org.apache.lucene.document.Document objects to IndexWriter
object. Each Document object corresponds to an Property object. The property Id is the key. The class com.dataServices.AddressSearch implements the creating the index and providing method for search.The implementation is as follows.

package com.dataServices;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;

import javax.xml.bind.JAXBException;

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.Searcher;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.store.RAMDirectory;

import com.objects.*;
import com.dataConversion.*;

public class AddressSearch {
    private RAMDirectory inMemoryIndex;
    private IndexWriter indexWriter;
    private Searcher searcher;
    private StandardAnalyzer standardAnalyzer;
    private QueryParser queryParser;
    private Hashtable<String, Property> addressLookup= null;
    private static AddressSearch addressSearch;
    //Default file path
    private String xmlFilePath = "C:/java/nrhp.xml";

    private AddressSearch() throws CorruptIndexException, LockObtainFailedException, IOException, JAXBException {
        inMemoryIndex = new RAMDirectory();
        indexWriter = new IndexWriter(inMemoryIndex, new StandardAnalyzer());
        addressLookup = new Hashtable<String, Property>();
        buildIndex();
        searcher = new IndexSearcher(inMemoryIndex);
        standardAnalyzer = new StandardAnalyzer();
        queryParser = new QueryParser("data", standardAnalyzer);
        queryParser.setAllowLeadingWildcard(true);
    }

    private void buildIndex() throws JAXBException, CorruptIndexException, IOException {
        List<Property> propList = getAddressList();
        Document doc = null;
        StringBuffer sb = null;
        for (Property p: propList) {
            doc = new Document();
            sb= new StringBuffer();
            if ((p.getId()==null)||(p.getAddress()==null)) continue;
            doc.add(new Field("propId", p.getId().toString(),Field.Store.YES, Field.Index.NO));
            if ((p.getAddress()==null) || (p.getCity()==null) || (p.getState()==null))
                continue;
            sb.append(p.getAddress().replaceAll(" ", "")).append(p.getCity().replaceAll(" ", ""));
            doc.add(new Field("data", sb.toString(), Field.Store.COMPRESS, Field.Index.TOKENIZED));
            indexWriter.addDocument(doc);
            //also add to HashTable
            addressLookup.put(p.getId().toString(), p);
        }
        indexWriter.optimize();
        indexWriter.close();
    }

    public List<Property> search(String searchString) throws ParseException, IOException {
        List<Property> results = new ArrayList<Property>();
        Query query = queryParser.parse(searchString);
        Hits hits = searcher.search(query);
        if (hits.length() != 0)
            for (int i=0; i< hits.length(); i++) {
                results.add(addressLookup.get(hits.doc(i).get("propId")));
            }
        return results;
    }

    public static synchronized AddressSearch getAddressSearch() throws Exception{
        if (addressSearch == null)
            addressSearch = new AddressSearch();
        return addressSearch;
    }

    private List<Property> getAddressList() throws JAXBException {
        Xml2Obj x2o = new Xml2Obj();
        return x2o.getAddressList(xmlFilePath);
    }

    public static void initialize(String xmlFile) throws Exception {
        getAddressSearch();
    }
}

The class com.dataServices.GetAddress is a HttpServlet that provides the address search functionality by accessing the  AddressSearch object. The result of the search is a list of Property objects, which match the search term. The Property objects are converted to xml using the class Obj2Xml and sent back as response.The addressSuggestion.jsp is the client side page, through which the users can type in address. The important javascript methods which does the ajax resquest and handing the response is shown below.

//For Ajax
var req;

function init() {
    if (window.XMLHttpRequest)
        req = new XMLHttpRequest;
    else if (window.ActiveXObject)
        req = new ActiveXObject("Microsoft.XMLHTTP");
    var url = 'http://' + location.host + '/AjaxAddressSugg/GetAddress';
    req.open("POST", url, true);
    req.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
}

function initiateSearch() {
    var searchString = document.getElementById('address').value;
    if ((searchString == null) || (searchString.length < 3)) {
        return;
    }
    init();
    req.onreadystatechange = displayResults;
    var request="searchString="+searchString;
    req.send(request);
}

function displayResults() {
    if (req.readyState == 4) {
        if (req.status == 200) {
            var propertyTags = req.responseXML.getElementsByTagName('property');
            for (var i=0; i< propertyTags.length; i++) {
                var full_address = "
<table width='100%' cellspacing='0' cellpadding='1'>
<tr style='background-color: #CCDEF7;'>
<td><b>";
                for (var j=0; j< propertyTags&#91;i&#93;.getElementsByTagName('name').length; j++)
                full_address = full_address +
                                propertyTags&#91;i&#93;.getElementsByTagName('name')&#91;j&#93;.firstChild.nodeValue;
                full_address =  full_address + "</b></td>
</tr>
<tr style='background-color: #DDE9FB;'>
<td>" +
                        propertyTags[i].getElementsByTagName('address')[0].firstChild.nodeValue
                        + ' ' + propertyTags[i].getElementsByTagName('city')[0].firstChild.nodeValue
                        + ' ' + propertyTags[i].getElementsByTagName('state')[0].firstChild.nodeValue
                        + '</td>
</tr>
</table>
';
                var row = document.getElementById('table001').insertRow(-1);
                var cell = row.insertCell(-1);
                cell.innerHTML = full_address;
            }
        }
    }
}

function removeResults() {
    var resultsTable = document.getElementById('table001');
    var records = resultsTable.rows.length;
    for (var i=(records-1); i> 0; i--)
        resultsTable.deleteRow(i);
}

I have attached the screen shot of one of the searches below.On my laptop with 1.66 Ghz Intel Core Duo and 2 GB RAM, and java version 1.6.0_02 the response was around 170-250 ms.
The code can be improved a lot through optimization, which the current implementation lacks.I have enclosed the war file, which includes the source code. The war file is successfully tested on Tomcat and Glassfish.

The search fails in some cases with the following exception.

org.apache.lucene.search.BooleanQuery$TooManyClauses: maxClauseCount is set to 1024

This happens when the search string you entered results in more than 1024 tokens. This can be fixed by increasing maxClauseCount in the BooleanQuery class to 2048.

Also, the ajax search begins when user enters minimum of 3 characters.

The servlet above is not thread-safe.

Update

The  servlet has been changed to fetch the location of the xml data file from web.xml instead of using workaround.

Quick Preview

Resources

trang.jar

SourceCode and WAR file

AjaxAddressSugg.war

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

public class GetUniqueLines {

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(args[0]));
        Set<String> s = new LinkedHashSet<String>();
        String line = null;
        while ((line = br.readLine())!= null)
            s.add(line);
        Iterator<String> it = s.iterator();
        BufferedWriter bw = new BufferedWriter(new FileWriter(args[1]));
        while (it.hasNext()) {
            bw.write(it.next());
            bw.newLine();
        }
        bw.close();
        br.close();
    }
}

8 lines of imports for 12 lines of code.

Canvas HTML element is used to create graph. Canvas HTML element is part of HTML 5 Specification. Hence, any browser that confirms to HTML 5 specification should be able to properly render the Canvas element. As of now Firefox(above 1.5v) and Opera supports this. IE doesn’t support this tag, but there is a workaround.

A snapshot of the line graph. Since, i have used random number generator for generating the values, the graph is more random.

This is the JavaScript source code, which generated the graph.

var graphArray;
function populateGraphArray() {
  //value can be anything from 0 to 100
 graphArray = new Array();
 var randomnumber;
 for (var i=0; i< 200 ; i++){   graphArray[i] = Math.floor(Math.random()*101);  } } function drawGraph() {   var canvas = document.getElementById("graphCanvas");   var graphWidth = canvas.width;   var graphHeight = canvas.height;   if (canvas.getContext) {   var ctx = canvas.getContext("2d");  ctx.beginPath();  //Draw the x and y axis  ctx.lineWidth = 5;  ctx.lineTo(0, 0);  ctx.lineTo(0, graphHeight);  ctx.lineTo(graphWidth, graphHeight);  ctx.stroke();  //Draw the Graph  ctx.lineWidth = 1;  ctx.strokeStyle='rgb(114, 172, 216)';  var unitX;  var unitY;  if (graphHeight > 100)
  unitY = Math.floor(graphHeight/100);
 else
  unitY = Math.floor(100/graphHeight);
 if ( graphWidth > graphArray.length)
  unitX = Math.floor(graphWidth/graphArray.length);
 else
  unitX = Math.floor(graphArray.length/graphWidth);
 for (var i=0; i < graphArray.length; i++){   if (i==0)   ctx.moveTo(unitX*i, (graphHeight - (graphArray[i]*unitY)));   ctx.lineTo(unitX*i, (graphHeight - (graphArray[i]*unitY)));  }  ctx.stroke();   } }[/sourcecode]
“graphCanvas” is the Canvas element in the HTML page. The code is pretty simple if you go through the documentation on Canvas at Mozilla Developer Center.

Our logic just boils down to generate the x and y coordinate values, which usually will be a small algorithm.

You can also create a bar graph with just 2 lines of code change. The bar graph generated is..

The javascript code is

  function drawGraph() {
  var canvas = document.getElementById(“graphCanvas”);
  var graphWidth = canvas.width;
  var graphHeight = canvas.height;
  if (canvas.getContext) {
  var ctx = canvas.getContext(“2d”);
  ctx.beginPath();
  //Draw the x and y axis
  ctx.lineWidth = 5;
  ctx.lineTo(0, 0);
  ctx.lineTo(0, graphHeight);
  ctx.lineTo(graphWidth, graphHeight);
  ctx.stroke();
  //Draw the Graph
  ctx.lineWidth = 1;
  ctx.strokeStyle=’rgb(80, 45, 46)’;
  var unitX;
  var unitY;
  if (graphHeight > 100)
  unitY = Math.floor(graphHeight/100);
  else
  unitY = Math.floor(100/graphHeight);
  if ( graphWidth > graphArray.length)
  unitX = Math.floor(graphWidth/graphArray.length);
  else
  unitX = Math.floor(graphArray.length/graphWidth);
  ctx.lineWidth = unitY;
  for (var i=0; i < graphArray.length; i++){   ctx.moveTo(unitX*i, graphHeight);   ctx.lineTo(unitX*i, (graphHeight - (graphArray[i]*unitY)));   }   ctx.stroke();   }   }[/sourcecode] References

• Mozilla Developer Center

Source Code Download

• Link

The Java Message Service (JMS) API is a Java Message Oriented Middleware (MOM) API for sending messages between two or more clients. JMS is a part of the Java Platform, Enterprise Edition, and is defined by a specification developed under the Java Community Process as JSR 914.

– Source www.wikipedia.com

There are already a lot of resources about JMS on net. Hence, I will not elaborate more on this.

I have provided some links in the references section, which i found to be of great help in understanding JMS.

This post is about my experience of developing a simple JMS application using Glassfish Application Server. The IDE used is Eclipse. The messaging model is Point to Point.

The functionality of the application to be implemented.

This application provides a JMS consumer, which accepts ObjectMessage from the JMS producers. The ObjectMessage object encapsulates a User object. The User object is similar to objects in a typical business application. The JMS Consumer persists the User object. The JMS producer is a part of a typical online application, which sends the User object, whenever a new user registers for the service. And, the Consumer can be thought as a module, which performs certain operations with the User data with interfacing systems, which together provide a business work flow.

This the UML diagram of the User object.

The JMS Consumer just persists the User object in database.  The User class is part of a projBeans.jar jar file. Since, this class is common for both the server and client module, i have created a separate jar for the User Class.

Developing the server part of the application.

The server part of the application includes the JMS Consumer module, setting up connection factory and destination resource in the Glassfish application Server together with the database setup.

The web based admin console of the Glassfish application server can be accessed at port number 4848. Create a new JMS Connection factory persistUserConnectionFactory of type QueueConnectionFactory and a new JMS Destination Resource persistUserQueue of type Queue.

I have used EJB 3 Annotations to develop the Message Beans.

Create a New java project in Eclipse and implemented the following classes.

The JMS Consumer is the UserMessageListener Class, which is implemented as follows.

package com.ebeans.message;

import javax.ejb.MessageDriven;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import org.apache.log4j.Logger;
import com.beans.User;
import com.persist.db.PersistUser;

@MessageDriven(mappedName = "persistUserQueue")
public class UserMessageListener implements MessageListener{

	static Logger log = null;

	static {
 	log = Logger.getLogger(UserMessageListener.class);
 }

	public UserMessageListener() {
 }

	@Override
 public void onMessage(Message arg0) {
 	Object obj = null;
 	if (arg0 instanceof ObjectMessage) {
 		try {
 			obj = ((ObjectMessage)arg0).getObject();
 		} catch (JMSException e) {
 			e.printStackTrace();
 			log.error("Message could not be casted to ObjectMessage", e);
 		}
 		if (obj instanceof User) {
 			log.info("User object will be persisted." + ((User)obj).toString());
 			PersistUser persist = new PersistUser();
 			persist.persistToDb((User)obj);
 		}
 	}
 	else {
 		log.warn("ObjectMessage is not of type User." + obj.getClass());
 	}
 }

}

A class needs to implement the MessageListener interface to be a Message Bean, and hence the class UserMessageListener.The interface MessageListener has the following method, that needs to be overridden. This is the method, which is called by the JMS container when a message is received by the application server.

public void onMessage(Message arg0) {
}

This method includes the message processing logic. In this method, i create an instance of PersistUser and invoke the method persistToDb to persist the User object to database. The database used here is Derby.The implementation of the class PersistUser  is as follows.

package com.persist.db;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import java.sql.DriverManager;
import org.apache.log4j.Logger;
import com.beans.User;

public class PersistUser {

	static String dbDeryUrl = "jdbc:derby://localhost:1527/sample";

	static Logger log = null;

	static {
 	log = Logger.getLogger(PersistUser.class);
 }

	public PersistUser() {

	}
 public void persistToDb(User obj) {
 	Connection conn = null;
 	try {
 		Class.forName("org.apache.derby.jdbc.ClientDriver");
 		Properties prop = new Properties();
 		prop.put("user", "system");
 		prop.put("password", "manager");
 		StringBuilder sb = getSqlQuery(obj);
 		log.info("SQL = " + sb.toString());
 		conn = DriverManager.getConnection(dbDeryUrl, prop);
 		Statement st = conn.createStatement();
 		st.execute(sb.toString());
 		conn.close();
 	} catch (ClassNotFoundException e) {
 		log.error("JDBC Driver could not be found.", e);
 		e.printStackTrace();
 	} catch (SQLException e) {
 		log.error("SQL Exception." + e);
 		e.printStackTrace();
 	}
 	finally {
 		if (conn != null) {
 			try {
 				conn.close();
 			} catch (SQLException e) {
 				log.error("SQL Exception in finally block." + e);
 				e.printStackTrace();
 			}
 		}
 	}
 }

	private StringBuilder getSqlQuery(User obj) {
 	StringBuilder sb = new StringBuilder();
 	sb.append("INSERT INTO USERSINFO (first_name, last_name, middle_name, age, country) VALUES ('")
 	  .append(obj.getFname())
 	  .append("','")
 	  .append(obj.getLname())
 	  .append("','")
 	  .append(obj.getMname())
 	  .append("',")
 	  .append(obj.getAge())
 	  .append(",'")
 	  .append(obj.getCountry())
 	  .append("')");
 	return sb;
 }
}

I have used Log4j for logging. Also, included javaee.jar (part of Glassfish library), projBeans.jar (for User Class) , derbyClient.jar and apache-log4j-1.2.15 libraries.The structure of the project in Eclipse project explorer is as follows.Next, create the table with defination as follows in Derby database.

CREATE TABLE USERSINFO (
           FIRST_NAME VARCHAR(20),
           LAST_NAME VARCHAR(20),
           MIDDLE_NAME VARCHAR(20),
           AGE INTEGER,
          COUNTRY VARCHAR(20) )

The database is also ready. Next, we need to pack up the java project developed above as a Enterprise Archive (EAR) file.To create the ear file, create a new Enterprise Application Project under J2EE section of New Project Wizard and include the java project previously developed as part of this project.Next, create a directory lib under EarContent directory of the Enterprise Application Project and add the following libraries.

• projBeans.jar
• derbyClient.jar
• apache-log4j-1.2.15

The structure of the Enterprise Application Project is as shown.

Now, export this project as EAR file using the export option available in eclipse. Since,  J2EE 5 Annotation feature, there is no requirement of deployment descriptor file required in the EAR file.

The EAR file is ready for deployment in the Glassfish Application Server.

Use the Glassfish application server Web based admin console to deploy the EAR. When deploying the EAR, enable the “Run Verifier” option. With this option turned on, the application server verifies the EAR file and deploys, if successfully verified. If the verification fails, a message is displayed on the web console. To check the complete log, the logs is located in the following location.

%glassfish_home%/domains/%your_domain%/logs/server.log

The JMS Consumer is now successfully deployed.

Developing the client part (JMS Producer)

The jms producer which we will be creating runs as a separate standalone java process outside the application server. Hence, we cannot make use of Annotations provided by EJB3 for developing the jms producer module.

The implementation of the jms producer class UserJMSClient is as follows.

package com.client;

import javax.jms.JMSException;
import javax.jms.ObjectMessage;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.Session;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import com.beans.User;

public class UserJMSClient {
 InitialContext jndi = null;
 QueueConnectionFactory qFactory = null;
 Queue queue = null;
 boolean initialized = false;

	private void initialize() throws NamingException {
 	jndi = new InitialContext();
 	qFactory = (QueueConnectionFactory)jndi.lookup("persistUserConnectionFactory");
 	queue = (Queue)jndi.lookup("persistUserQueue");
 }

	public void sendObject(User user) throws Exception {
 	if (!initialized) {
 		try {
 			initialize();
 		} catch(NamingException e) {
 			e.printStackTrace();
 			throw new Exception("Jndi lookup failed");
 		}
 		initialized = true;
 	}
 	try {
 		QueueConnection qConn = (QueueConnection)qFactory.createQueueConnection();
 		Session session = qConn.createSession(false, Session.AUTO_ACKNOWLEDGE);
 		ObjectMessage oMsg = session.createObjectMessage(user);
 		session.createProducer(queue).send(oMsg);
 	} catch (JMSException e) {
 		e.printStackTrace();
 		throw new Exception("sendObject Method Failure");
 	}
 }
}

The class uses the JNDI to obtain references to QueueConnectionFactory and Queue. Included the following jar files.

• javaee.jar (%glassfish%\lib)
• projBeans.jar
• junit-4.4.jar
• imqjmsra.jar (%glassfish%/lib\install\applications\jmsra)
• appserv-rt.jar (%glassfish%\lib)
• sun-appserv-ant.jar (%glassfish%\lib)

The following is the project structure in Eclipse.

To test the UserJMSClient class,  i have used JUnit test case.

On executing the JUnit test case, the UserJMSClient object sent an User object to JMS consumer running in the application server. The JMS Consumer persisted the user object to the derby database, which i verified by querying the database.

A simple JMS based application has been developed and verified successfully. This blog is more of practical implementation of JMS.

References

• Java Message Service – Wikipedia article
• Java Message Service – Sun’s Documentation
• JMS Messaging Using GlassFish

Resources

• Eclipse (WTP)
• Glassfish Application Server
• Apache Derby
• Apache Log4j
• JUnit

Source Code

• Client Code (JMS Producer)
• Server Code (JMS Consumer)
• Common Jar File