<bean-action bean="cartController" method="changeQuantities">

 	<method-arguments><argument expression="flowScope.viewCommand"/></method-arguments>

 	<method-result name="viewCommand" scope="flow"/>

 </bean-action>

However Spring WebFlow has many aspects that would stop you from using it for entire site. Click-around navigation and SWF do not play well together.
So what I need is ability to define OGNL expression in Spring coonfig without using SWF. What looked scarry on first sight turned to be extremely easy task.
I did some prototyping of idea and here is what I got in spring config file:

 <bean id="profileView" class="com.cochlear.mcc.web.GenericFormController">

 	<property name="formView" value="profileView"/>

 	<property name="manager"><ref bean="profileManager"/></property>

 	<property name="viewScript"><value>manager.getProfile()</value></property>

 </bean>

 <bean id="profileForm" class="com.cochlear.mcc.web.GenericFormController">

 	<property name="formView" value="profileForm"/>

 	<property name="manager"><ref bean="profileManager"/></property>

 	<property name="modelClass"><value>com.cochlear.mcc.profile.model.ProfileDTO</value></property>

 	<property name="viewScript"><value>manager.getProfile()</value></property>

 	<property name="postScript"><value>manager.updateProfile(#object)</value></property>

 	<property name="successView" value="redirect:profile.view"/>

 </bean>

Not as clear as in SWF maybe but enough to prove the idea. It is concise, it does the job. You do not have to write FormActions for trivial things.
Here is what I have in GenericFormController:

public class GenericFormController extends SimpleFormController{

 protected Object manager;

 protected String viewScript;

 protected String postScript;

protected Object formBackingObject(HttpServletRequest request) throws ServletException, InstantiationException, IllegalAccessException {

 	try {

     	if(StringUtils.hasText(viewScript)){

 			OgnlContext context= new OgnlContext();

 			populateOgnlContextCommon(context, request);

 			Object expr = Ognl.parseExpression(viewScript);

 			Object res=Ognl.getValue(expr, context, this);

 			return res;

     	}else{

     		return getCommandClass().newInstance();

     	}

 	} catch (OgnlException e) {

 		e.printStackTrace();

 		throw new ServletException(e);

 	}

    }

protected ModelAndView onSubmit(HttpServletRequest request, HttpServletResponse response,

                                    Object commandObject, BindException errors) throws Exception {

Object command = getCommandClass().cast(commandObject);

 	try {

     	if(StringUtils.hasText(postScript)){

 			OgnlContext context= new OgnlContext();

 			context.put("command", command);

 			populateOgnlContextCommon(context, request);

 			Object expr = Ognl.parseExpression(postScript);

 			Ognl.getValue(expr, context, this);

     	}else{

     		throw new ServletException("No postScript specified");

     	}

 	} catch (Exception e) {

 		errors.reject(null, "Error:"+e.getMessage());

 		return showForm(request, errors, getFormView());

 	}

return new ModelAndView(getSuccessView());

    }

protected void populateOgnlContextCommon(OgnlContext context, HttpServletRequest request){

 	  context.put("request", request);

 	  context.put("session", request.getSession());

 	  context.put("user", SecurityContextHolder.getContext().getAuthentication().getPrincipal());

    }

// Getters and Setters here ..

 // ...

}

When I have time I will do something more production grade. For now I just glad to know that it is achievable and quite simple actualy.

DiggIt | del.icio.us

#!/bin/bash
#
# Startup script for Tomcat
#
# chkconfig: 345 84 16
# description: Tomcat jakarta JSP server
TOMCAT_HOME=/usr/share/apache-tomcat-5.5.20
TOMCAT_START=$TOMCAT_HOME/bin/startup.sh
TOMCAT_STOP=$TOMCAT_HOME/bin/shutdown.sh
#Necessary environment variables
export JAVA_HOME=”/usr/share/jdk1.5.0_10?
export CATALINA_HOME=”/usr/share/apache-tomcat-5.5.20?
#export LD_KERNEL_ASSUME=”2.2.5?
# Source function library.
. /etc/rc.d/init.d/functions
# Source networking configuration.
. /etc/sysconfig/network
# Check that networking is up.
[ ${NETWORKING} = “no” ] && exit 0
#Check for tomcat script
if [ ! -f $TOMCAT_HOME/bin/catalina.sh ]
then
    echo “Tomcat not available…”
    exit
fi
start() {
    echo -n “Starting Tomcat: “
    su - tomcat -c $TOMCAT_START
    echo
    touch /var/lock/subsys/tomcatd
# We may need to sleep here so it will be up for apache
    sleep 3
#Instead should check to see if apache is up by looking for httpd.pid
}
stop() {
    echo -n $”Shutting down Tomcat: “
    su - tomcat -c $TOMCAT_STOP
    rm -f /var/lock/subsys/tomcatd
    echo
}
status() {
    ps ax –width=1000 | grep “[o]rg.apache.catalina.startup.Bootstrap start” | awk ‘{printf $1 ” “}’ | wc | awk ‘{print $2}’ > /tmp/tomcat_process_count.txt
   read line

Add user tomcat. Please note that it is normal user with his own home. Many times it was very useful.

adduser tomcat

Set JAVA_HOME for all users in /etc/profile.d/java.sh . When we run ’su – tomcat’ this script will set up our environment:

export JAVA_HOME=/usr/share/jdk1.5.0_10

Give enough permissions to tomacat:

chown tomcat /usr/share/apache-tomcat-5.5.20/ -R

Now you are able to run tomcat with

service tomcatd start

The last thing is to run it when system boots:

chkconfig –add tomcatd
chkconfig tomcatd on

Done

There is other approach that is much more concise and programmer friendly (tm:) . The trick is to construct and submit form on-the-fly. Let’s start with JavaScript function that exploits Prototype:

// Expects URL with queryString as param href
function createAndSubmitDynamicForm(href){
	try{
		var lex1 = href.split('?');
		var action= lex1[0];
		var qstr = lex1[1];

		var insertion="<form id='dynamicPostForm' method='POST' action='"+action+"'>";
		if(qstr != null) {
			var params = qstr.split('&');
			(params).each(function(param){
				var keyValue = param.split('=');
				var name = keyValue[0];
				var value = keyValue[1];
				insertion += "<input type='hidden' name='"+name+"' value='"+value+"'/>";
			});
		}
		insertion += "</form>";

		new Insertion.After($('anyDivAtTheEndOfBody'), insertion);
		$('dynamicPostForm').submit();
	}catch(e){
		alert("Error"+e);
	}
}

Code is pretty much self explanatory hence not optimal. You can easily make it twice shorter if you need. Now is time to make a JSP tag that will expose our function in a nice way.

<%@ taglib uri="http://www.springframework.org/tags" prefix="spring" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<%@ attribute name="code" required="true"%>
<%@ attribute name="href" required="true"%>
<%@ attribute name="confirmMessage" required="false"%>
<%@ attribute name="css" required="false"%>
<input type="button"
	   value="<spring:message code="${code}"/>"
	   class="${css}"
	   onclick="<c:if test="${ ! empty confirmMessage}">if (confirm('<spring:message code="${confirmMessage}"/>')) </c:if>createAndSubmitDynamicForm('${href}');"/>

One thing to mention. We can have optional parameter ‘confirmMessage’ that will ask user if he really wants to submit the form. It is necessary whenever you place buttons ‘Remove’, ‘Delete’, ‘Make-Something-Horrible’ buttons. After plugging you JSP tag you will be able to have on the page something like:

<myTag:post href="controller.htm?action=payDebt&from=savingAccount&to=creditAccount&when=now" code="my.localized.button.name"/>

It is even simpler and better than

<a href="">

HTML tag!

Don’t thank me. At least yet. There is one more feature. Assume that you want to include really dynamic parameters in this POST. Let say you have number of products on the page and under each product there is ‘quanity’ field and ‘Add to Cart’ button. Solution is quite simple again. These is updated version of JS function:

// Expects URL with queryString as param href. Can have {name} placeholders for values of input fields
function createAndSubmitDynamicForm(href){
	try{
		var lex1 = href.split('?');
		var action= lex1[0];
		var qstr = lex1[1];

		var insertion="<form id='dynamicPostForm' method='POST' action='"+action+"'>";
		if(qstr != null) {
			var params = qstr.split('&');
			(params).each(function(param){
				var keyValue = param.split('=');
				var name = keyValue[0];
				var value = keyValue[1];
				// we can have runtime(js) placeholders in params
				if (value.match("^{w+}$")){
					var fieldName = value.substr(1, value.length-2);
					value = $F(fieldName);
				}
				insertion += "<input type='hidden' name='"+name+"' value='"+value+"'/>";
			});
		}
		insertion += "</form>";

		new Insertion.After($('anyDivAtTheEndOfBody'), insertion);
		$('dynamicPostForm').submit();
	}catch(e){
		alert("Error"+e);
	}
}

So now we can have such peace of HTML:

...
<input type='text' id='quantity' value='1'/>
<myTag:post href="cartController.htm?action=addToCart&itemId=123&quantity={quantity}" code="add.to.cart"/>
...

Done.

For my recent project I had to build a form having 6 different sets of fields. Depending on selected value in combo-box I process specific set. The rest of fields are ignored. That was easy to decide but how to tell Spring no to bind some fields?

One approach is to process input manually disabling automatic binding by overriding supressBinding function:

protected boolean suppressBinding(HttpServletRequest request) {
  return false;
}

Will work but leaves whole burden of binding on your shoulders. You do not want that. The other approach is letting Spring know which fields you want to process and which not. Take a look:

protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder) {
  super.initBinder(request, binder);
  if (! isFormSubmission(request))
    return ;
  try {
    String selectedBenefitType = ServletRequestUtils.getRequiredStringParameter(request, "benefitType");
    List disallowedFields = new ArrayList();
    //disallow processing of any field that do not belong to currently selected benefit
    for (String benefitType:BaseBenefit.benefitTypes){
      if (! selectedBenefitType.equalsIgnoreCase(benefitType)){
        String fieldMask = StringUtils.uncapitalize(benefitType)+".*";
        disallowedFields.add(fieldMask);
      }
    }
    binder.setDisallowedFields(disallowedFields.toArray(new String[disallowedFields.size()]));
    binder.setRequiredFields(new String[]{"benefitType", "sinceDate", "untilDate"});
  } catch (ServletRequestBindingException e) {
    logger.error(e.getMessage(), e);
    throw new RuntimeException(e);
  }
}

Here we pass list of unwanted fields to binder.setDisallowedFields and that is it. Those fields will not be bound and you will not receive ‘Can not convert field someDate to java.util.Date’ for fields that are not wanted, not filled and even hidden on the form. As you have probably noticed You can use wild-cards in field names.

I like Spring a lot. And I use it in every single Java project I do. So take my advice. When you want to use Spring MVC seriously, the first step is to tear away Spring MVC paragraph from documentation so you do not pretend that you have it at all. Read an API and dig into source code. Soon you will discover that your web-tier improved a lot.

Ascon user interface mainly provide functionality for managing(CRUD) user’s addressbook and CallJobs. In list of CallJobs user should also have ability to see kind a report for completed jobs.

When CallJob executed we need to place a call and when answered read out the text of message. After that JobCall is considered as completed. If nobody answers the call we mark it as dismissed. In next versions we might want to introduce “redial schedule” for repeating unaswered calls until completion.

For incoming calls we are going to have conventional IVR service with arbitrary dialog.

Operator has all functionality as normal user, report for all users, report for all JobCalls and ability to manage Carriers.

public Object unmarshall(SerializerState state, Class clazz, Object o)
...
Method setMethod = (Method)bd.writableProps.get(field);
if(setMethod != null) {
    ...
    setMethod.invoke(instance, invokeArgs);
    ...
}

The class is responsible of transforming Json notation to your Java Bean. Looking at code I realised that when no setter is present for field(or you mistyped field name in JSON) nothing happens. Nothing is set on the Bean obviously and no exception is thrown! Is some situation it makes sence. Silently dropping of absent fields is nice feature when you write backward compatible code or similar. But in most cases you want to rise an exception when field name does not match to Java bean fields. So I suggest to modify this code like following:

while(i.hasNext()) {
    String field = (String)i.next();
    Method setMethod = (Method)bd.writableProps.get(field);
    if(setMethod != null) {
	try {
	    Class param[] = setMethod.getParameterTypes();
	    fieldVal = ser.unmarshall(state, param[0], jso.get(field));
	} catch (UnmarshallException e) {
	    throw new UnmarshallException("bean " + clazz.getName() + " on field "+ field +
					  " " + e.getMessage());
	}
	if(ser.isDebug())
	    log.fine("invoking " + setMethod.getName() +
		     "(" + fieldVal + ")");
	invokeArgs[0] = fieldVal;
	try {
	    setMethod.invoke(instance, invokeArgs);
	} catch (Throwable e) {
	    if(e instanceof InvocationTargetException)
		e = ((InvocationTargetException)e).getTargetException();
	    throw new UnmarshallException("bean " + clazz.getName() + "can't invoke " +
				 setMethod.getName() + ": " + e.getMessage());
	}
    }else{
    	if( ! "javaClass".equals(field)){
 		throw new RuntimeException("Class "+clazz +" does not have setter for field " + field +"!");
   	}//if
    }

The next step would be to introduce lenientMarshalling configuration parameter for JSON-RPC bridge that controll strictness of marshalling operations.

#!/bin/sh
HOST=127.0.0.1
PORT=8080

#infinite loop
while [ 1 ]
do
	#try to access tomcat's page
	RES=`wget -O - -o /dev/null --proxy=off http://${HOST}:${PORT}/isalive.html | awk '{ print $1 }'`
	echo got ${RES}
	#decide on reply
	if [ "$RES" = "YES" ]
	then
		echo tomcat is responding on $HOST:$PORT
	else
		echo tomcat seems to be dead.
		echo Killing...
		for thepin in `ps -Af | grep -v grep | grep tomcat | grep catalina | awk '{ print $2 }'`
		do
			kill -9 ${thepin}
		done
		echo Starting...
		sudo -u tomcat /usr/local/tomcat/bin/startup.sh
	fi

sleep 60
done

Here is just some numbers from jobserve.com.au. All keywords were prefixed with Sydney AND Java AND statement. The search for Sydney AND Java only gives 500 matching jobs.
AppServer:

1. WebSphere – 56
2. WebLogic – 47
3. Tomcat – 41
4. JBoss – 32
5. Sun -21
6. JRun – 3
7. GlassFish – 0
8. Geronimo – 0

DataBase:

1. Oracle – 146
2. Sybase – 69
3. DB2 – 24
4. MySql – 18
5. MS Sql – 10
6. Postgres – 1
7. Derby – 0

Mapping:

1. Hibernate – 85
2. JDBC – 26
3. JDO – 4
4. Toplink – 0

MVC and templating:

1. STRUTS – 75
2. Swing – 10
3. Spring MVC – 9
4. JSF – 8
5. Tapestry – 4
6. Sitemesh – 0
7. Tiles – 0
8. RIFE – 0

OS:

1. UNIX – 110
2. Microsoft – 55
3. Solaris – 37
4. Linux – 32

Scripting

1. Perl – 47
2. Shell – 34
3. JavaScript – 33

Build, testing, etc

• JUnit – 31
• ant – 22
• maven -4
• continuum – 1

Frameworks, technologies and other TLA:

• Spring – 66
• SDLC – 60
• Agile – 20
• UML – 61
• SOA – 8
• WebServices – 4
• SOAP – 13
• BPEL – 3
• EJB – 45
• JMS – 26
• JMX – 0
• Tibco – 13
• AJAX – 4
• PHP – 5
• Eclipse – 51
• HTML – 71
• JSP – 86
• XML – 145
• XSL – 26
• XSLT – 22

package com.maersk.hrb.dao;

import java.io.Serializable;
import java.util.List;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.DetachedCriteria;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class GenericDao  extends HibernateDaoSupport {
    private Class modelClass;
    private SessionFactory sessionFactory;

public GenericDao(Class modelClass) {
        this.modelClass = modelClass;
    }

public PK create(T o) {
        return (PK) getHibernateTemplate().save(o);
    }

public T read(PK id) {
        return (T) getHibernateTemplate().get(modelClass, id);
    }

public void update(T o) {
    	getHibernateTemplate().update(o);
    }

public void delete(T o) {
    	getHibernateTemplate().delete(o);
    }

public List getObjects(DetachedCriteria criteria) {
		return getHibernateTemplate().findByCriteria(criteria);
	}

public List getObjects(Serializable[] ids) {
		return getHibernateTemplate().find("from "+modelClass.getSimpleName()+" alias where alias.id in ?", ids);
	}

public List getObjects() {
		return getHibernateTemplate().find("from "+modelClass.getSimpleName());
	}
}

Nothing new here. Well known generic DAO. I do not have any finder method here because my application is really simple. Anyway finders would bring big difference to idea.
So this is our generic manager:

package com.maersk.hrb.domain.logic;

import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.NotImplementedException;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.DetachedCriteria;

import com.maersk.hrb.dao.GenericDao;
import com.maersk.hrb.domain.BaseObject;

public class GenericManager {
    private Class modelClass;
    private Class
pkClass;
	private GenericDao dao;

private static Map managersMap = new HashMap();

public GenericManager(Class modelClass, Class
pkClass) {
        this.modelClass = modelClass;
        this.pkClass = pkClass;
        this.dao = new GenericDao(modelClass);
        managersMap.put(modelClass, this);
    }

public static GenericManager lookupManagerByClass(Class modelClass){
    	return (GenericManager) managersMap.get(modelClass);
    }

public static GenericManager lookupManagerByClassName(String modelClassName){
    	Class modelClass;
		try {
			modelClass = Class.forName(modelClassName);
		} catch (ClassNotFoundException e) {
			throw new RuntimeException(e.getMessage(), e);
		}
    	return (GenericManager) managersMap.get(modelClass);
    }

public  static GenericManager lookupManagerBySimpleClassName(String modelClassName){
    	return lookupManagerByClassName("com.maersk.hrb.domain."+modelClassName);
    }

public void setSessionFactory(SessionFactory sessionFactory) {
		if (dao != null)
			dao.setSessionFactory(sessionFactory);
	}

public GenericManager(Class modelClass) {
    	this(modelClass, (Class
) Long.class);
    }

public Class getModelClass() {
		return modelClass;
	}

public void setDao(GenericDao dao) {
        this.dao = dao;
    }

public T getObject(String id) {
        try {
			Constructor
constructor = pkClass.getConstructor(String.class);
			PK newInstance = (PK)constructor.newInstance(id);
			return dao.read(newInstance);
		} catch (Exception e) {
			throw new RuntimeException("Wrong PK class");
		}
    }

public List getObjects(DetachedCriteria criteria) {
    	return dao.getObjects(criteria);
    }

public List getObjects(String[] ids) {
        return dao.getObjects(ids);
    }

public List getObjects(Serializable[] ids) {
        return dao.getObjects(ids);
    }

public T getObject(Long id) {
        return dao.read((PK)id);
    }

public List getObjects() {
        return dao.getObjects();
    }

public void removeObject(String id) {
        T object = getObject(id);
        dao.delete(object);
    }

public boolean isFieldValueUnique(String fieldName,Object fieldValue, T currentObject) {
    	throw new NotImplementedException("Not yet, sorry");
    }

public void saveObject(T object) {
    	if(object.isNew())
    		dao.create(object);
    	else
    		dao.update(object);
    }
}

Each manager creates his own DAO and registers itself in map. Note three lookup methods allowing us to get managers for specific model class. It is the sample of ‘Conventioin over Configuration’ principle. What the point of assigning managers to facade if we can explicitly get them when and where we need it? What is the point of defining Spring beans for DAO if the only place we use them is managers? The coupling here is not tough and I have no problem with that. Afterall coupling is evel thing when you try plug different implementations of modules, refactor, or anyhow else intoduce significant changes.
Despite of some coupling here we obviously not gonna have such problems. The only thing that I do not like here is sessionFactory. Managers only need sessionFactory to pass to their DAOs. In next post I’ll address such issues. Now lets continue to our spring beans definitions:

<bean id="managerTemplate"  abstract="true">
	<property name="sessionFactory">
		<ref bean="sessionFactory"/>
	</property>
</bean><bean id="staffMemberManager" class="com.maersk.hrb.domain.logic.GenericManager"  parent="managerTemplate">
	<constructor-arg>
		<value>com.maersk.hrb.domain.StaffMember</value>
	</constructor-arg>
</bean>

<bean id="aidQualificationManager" class="com.maersk.hrb.domain.logic.GenericManager" parent="managerTemplate">
	<constructor-arg>
		<value>com.maersk.hrb.domain.AidQualification</value>
	</constructor-arg>
</bean>

<bean id="remunerationEventManager" class="com.maersk.hrb.domain.logic.GenericManager" parent="managerTemplate">
	<constructor-arg>
		<value>com.maersk.hrb.domain.RemunerationEvent</value>
	</constructor-arg>
</bean>

<bean id="staffPositionHeldManager" class="com.maersk.hrb.domain.logic.GenericManager" parent="managerTemplate">
	<constructor-arg>
		<value>com.maersk.hrb.domain.StaffPositionHeld</value>
	</constructor-arg>
</bean>

Simple, short. No more scroll-blindness when looking at applicationContext.xml! This is what I wanted.