JSF and PopUP

By default JSF has no support for PopUps, unless you are using any custom JSF component library like Tomahawk (http://myfaces.apache.org/tomahawk/index.html), it is tough to achieve pop ups in JSF.
Lets say we want to create a web page which shows a link and on click of that link, one popup should appear with details of the element clicked. This is a very standard requirement like on click of "username" the pop up window should display the details of the user. In JSF it becomes tough because onclick event we can fire a javascript but that is not in sync with the backend action bean.
There is however an easy solution for this problem. The solution is to do the followings
1. Create one controller and bind it to the request scope
2. On click, form a URL which will look like this "newpage.jsp?param1=val"
3. The controller should read the params passed in the URL and process accordingly, for example in this case, the param would be the name of the user and the controller should contact LDAP or backend database server to fetch details data.
The controller can get the details of the parameters passed along with the URL by using FacesContext.getCurrentInstance().getExternalContext().getRequestParameterValuesMap() - this will return the map whose key is the parameter name passed in the URL.

My Status update

wow just by looking at my blog, I am figuring out how much busy I was in last couple of months. Well, 2010 is here with lots of activity for myself. The first major change was breaking up with HP. It was a long relationship - around 7 years, found myself becoming very comfortable, so decided to leave and come to US as a consultant.
As a consultant, I am doing some pretty good work in last three month or so. I worked on JSF, worked on Webservices - Axis2 (and SwA).. its cool. I want to write about JSF 1.1 and PopUp, will post it as soon as I get some free time.

JAX-RPC and JAX-WS - how does the SOAP look?

Lets consider a method like the following –

public void purchaseOrder(String item, int quantity, String description)

When this method is serialized to SOAP packet using JAX-RPC engine, the packet looks like the below





This is called SOAP encoding. The method name is the root element under the Body tag of the soap packet. Each parameter is having type defined and the value. This type will be used by the SOAP brokers/engines to de-serialize to String or int values.

The same method needs to be written like “public void someMethod(PurchesOrder po)”
to be serialized to the similar SOAP packet using JAX-WS Document literal engine .
The same method can be left unchanged to be serialized to the similar SOAP packet using JAX-WS Document literal Wrapped (wrapped means, the parameters are wrapped inside the method name) engine .
The sample SOAP packet for JAX-WS is shown below-




In case of JAX-WS, the entire XML inside the Body is deserialized to an JavaBean following JAXB. The WSDL will contain the XSD for the PurchesOrder Bean.

Anti Patterns

Just finished reading this book on anti patterns. It is a very nice book which describes how we (the developer as well as the architects and managers) fail to deliver a software project properly even after all of our good intentions. Sometimes we follow wrong architecture, sometime the deadly sins of sloth, narrow-mindness, Apathy towards technology etc etc..
I quite like the anecdotal evidences that the authors have come up with for each of the well known anti patterns. While reading the book, sometimes I just jumped out from chair and shouted "oh god, I have experienced such problems before". I am sure, as a developer or lead or budding architect, I will be very careful now onwards to look for anti patterns while designing as well as while doing coding or reviews.

Futuristic Build Process

Build – by definition is to compile all the source code of a project and create the deliverables. For example, build is to compile all Java code using ant or maven and then create the executable jar files or war files or ear files.

An effective build system goes long way to help the project. Nightly or at least weekly development build bits are essential to check the status of the project. Lets divide build systems in its effectiveness.

Step 0 – Build system checks the syntax errors. This is really basic and a must do for build systems. If there is a syntax error in any code , build should fails. It usually does as the compiler stops if there is a syntax error.

Step 1 – Build fails if the unit test fails on the code. This is where most of current projects are. Build fires the compilation, followed by creation of deployable jars/wars. As the last step, build fires the JUnit test cases. If the JUnit test case fails, build breaks. This makes sure the build output is sane and no unit test cases have failed on the build output.

Step 2 – Now lets consider of a build system which breaks if the code checkin has more complexity than the standard, or if the code coverage of the code checkin is less. There are several software metrics that are available now, like “Code Coverage”, “Cyclomatic complexity of code”, “CRAP Metric (Change Risk Analyzer and Predictor)”. [ there are already plugins available on the CRAP and Cyclomatic Metric, where can be found here]

If Build system is integrated with calculation of these metrics, that would guarentee a uniform code complexity and if anytime code complexity numbers come high from the code analysis tools, build should break. This is surely a cool thing to do considering the fact that now-a-days much of the code is getting auto generated. Example, you have a webservice which was using Framework version 1 {like axis1} and you were compiling WSDL file to generate the stub code. You move to Version 2 and build breaks because the auto generated code is more complex and hard to maintain.

It should be a collective decision of the project team whether to go for higher complexity of the code as a team.


This is where at Step2, I think the next generation build systems will go.

How to connect to Tomcat to gather information from JMX MBeans?

Tomcat provides see of information through its JMX MBeans. It is also easy to connect to tomcat over JMX, just run tocat using the following options -

1. -Dcom.sun.management.jmxremote.port=9999


2. -Dcom.sun.management.jmxremote.ssl=false


3. -Dcom.sun.management.jmxremote.authenticate=false

This will start the tomcat server on port 9999. Use these JVM options in the catalina.bat file - and keep them as JAVA_OPTS.

Once tomcat has opened this port, connect to tomcat using this sample code -

1. JMXServiceURL jurl = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:9999/jmxrmi");


2. JMXConnector jmxc = JMXConnectorFactory.connect(jurl, null);


3. MBeanServerConnection mbsc = jmxc.getMBeanServerConnection();

This will connect to the tomcat server running on localhost with port 9999.

To fetch the value of an attribute - use the following code -

1. 
   mbsc.getAttribute(
   new ObjectName(ManagementFactory.RUNTIME_MXBEAN_NAME, "VmVersion");

The above code will fetch the JVM version of the tomcat JVM using the standard runtime MBean of the JVM.

Trie in Java

Trie is a good datastucture, details can be found here - http://en.wikipedia.org/wiki/Trie . I came across Trie while performing "Prefix" based searching. Have you ever Wondered what Data Structure is used behind the Mobile SMSes ? When we type SMS, it finishes the words or proposes what could be the end of the word. They are usually done by Trie or data structures like Trie.
Trie consumes less space so they are hot favourite data structures on PDAs or devices with less memory. Searching of a string in Trie takes around O(m) where m = length of the key. Compare it with Binary Tree which is O(logn) where n = number of elements in the tree. For a dictionary, this n could be real large.

Here is a simple implimentation of the Trie..
One class is called Node class which holds the Key and the value.

1. public class Node {




3. private char key;


4. private String value;


5. private List children;


6. private boolean isTerminal;


7. public boolean isTerminal() {


8. return isTerminal;


9. }


10. public void setTerminal(boolean isTerminal) {


11. this.isTerminal = isTerminal;


12. }


13. public Node(char key,String value)


14. {


15. this(key,value,new ArrayList());


16. }


17. public Node(char key, String value, List children) {


18. super();


19. this.key = key;


20. this.value = value;


21. this.children = children;


22. }




24. public char getKey() {


25. return key;


26. }


27. public void setKey(char key) {


28. this.key = key;


29. }


30. public String getValue() {


31. return value;


32. }


33. public void setValue(String value) {


34. this.value = value;


35. }


36. public List getChildren() {


37. return children;


38. }


39. public void setChildren(List children) {


40. this.children = children;


41. }




43. public void addChildren(Node child)


44. {


45. this.children.add(child);


46. }

}

And the Main Trie class which builds the tree and finds any key...

package com.ds.trie;

1. import java.io.BufferedReader;


2. import java.io.File;


3. import java.io.FileNotFoundException;


4. import java.io.FileReader;


5. import java.io.IOException;


6. import java.util.ArrayList;


7. import java.util.LinkedList;


8. import java.util.List;


9. import java.util.Queue;




11. public class Trie {




13. private Node root;


14. private File fname;




16. public Trie (String filename)


17. {


18. this.root = new Node('r',"root");


19. this.fname = new File(filename);


20. }




22. public void buildTrie()


23. {


24. try {




26. if (!fname.isFile())


27. throw new FileNotFoundException("");


28. BufferedReader f = new BufferedReader(new FileReader(fname));


29. String key;


30. try {


31. while ((key = f.readLine()) != null)


32. {


33. // making value = full name only = key


34. build(key,root,key);


35. }


36. } catch (IOException e) {


37. // TODO Auto-generated catch block


38. e.printStackTrace();


39. }


40. } catch (FileNotFoundException e) {


41. // TODO Auto-generated catch block


42. e.printStackTrace();


43. }


44. }




46. // key = shamik


47. private void build(String key,Node root,String value) {


48. // TODO Auto-generated method stub


49. char c = key.charAt(0); // c = s


50. String tail = null;


51. if (key.length() > 1)


52. tail = key.substring(1); // hamik


53. Node resultNode = findKeyinChildren(root,c); // find 's' in the children


54. if (resultNode == null)


55. {


56. // this is a new key


57. Node newNode = new Node(c,value);


58. if (tail == null)


59. newNode.setTerminal(true);


60. else


61. newNode.setTerminal(false);




63. root.addChildren(newNode);


64. if (tail == null)


65. {


66. return;


67. }


68. else


69. build(tail,newNode,value);


70. }


71. else // got the key - s


72. {


73. if (tail == null)


74. return;


75. build (tail,resultNode,value);


76. }


77. }




79. private Node findKeyinChildren(Node root, char c) {


80. // TODO Auto-generated method stub


81. List list = root.getChildren();


82. if (list == null || list.size() == 0)


83. return null;


84. for (int i=0; i < list.size(); i++)


85. {


86. Node oneNode = list.get(i);


87. if (oneNode.getKey() == c)


88. return oneNode;


89. }


90. return null;


91. }




93. public List findKey(String key)


94. {




96. String value = null;


97. List values = new ArrayList();




99. Node resultNode = findinTrie(key,root);




101. if (resultNode == null)


102. {


103. value = "Not found";


104. values.add(value);




106. }


107. else


108. {




110. printTree(resultNode,values);




112. }


113. return values;




115. }




117. private void printTree(Node resultNode,List values) {


118. // TODO Auto-generated method stub


119. List list = resultNode.getChildren();




121. if (resultNode.isTerminal())


122. values.add(resultNode.getValue());




124. if (list.size() == 0)


125. {




127. return;




129. }


130. else


131. {


132. for (int i=0; i<list.size();i++)


133. {


134. Node oneNode = list.get(i);


135. printTree(oneNode,values);


136. }


137. }


138. }




140. private Node findinTrie(String key, Node root) {


141. // TODO Auto-generated method stub


142. // Implementing the Breath First Traversal


143. char first = key.charAt(0);


144. String tail = null;


145. if (key.length() > 1)


146. tail = key.substring(1);




148. Node resultNode = this.findKeyinChildren(root, first);


149. if (resultNode == null)


150. {


151. return null;


152. }


153. else


154. {


155. if (tail == null)


156. return resultNode;


157. else


158. resultNode = findinTrie(tail,resultNode );


159. }




161. return resultNode;


162. }




164. public static void main(String[] args)


165. {


166. if (args.length <= 0)


167. {


168. System.out.println("Usage : Trie ");


169. System.exit(1);


170. }


171. Trie trie = new Trie("C:\\test\\dictionary");


172. trie.buildTrie();


173. System.out.println("Going to look for " + args[0]);


174. List vals = trie.findKey(args[0]);


175. for (int i=0; i<vals.size(); i++)


176. {


177. System.out.println("possible value = " + vals.get(i));


178. }




180. }




182. }