DevGrok

Bulk upload of maven artifacts to remote repo

2012-01-06T14:42:00.001+11:00

If you have an artifact you want to upload to a remote repository (i.e. internal company repo) then you use the command:

mvn deploy:deploy-file -Durl=file://C:\m2-repo \
                       -DrepositoryId=some.id \
                       -Dfile=your-artifact-1.0.jar \
                       [-DpomFile=your-pom.xml] \

However if you have more than a few files and they're in a nested directory structure (like your local repo) then this is not the way to do it. There doesn't seem to be any tool for either maven or nexus to do this, so here's a quick and dirty way I hacked together:

/**
 * run as java Importer [dirtosearch]
 **/
public class Importer {
   private String directory;
   private final static String repositoryId = "repo1";
   private final static String url = "http://remoteserver/nexus/content/repositories/repo1/";
   private final static String mvn = "C:/java/apache-maven-3.0.3/bin/mvn.bat";

   /**
    * @param directory
    */
   public Importer(String directory) {
      super();
      this.directory = directory;
   }

   public static void main(String[] args) {
      Importer importer = new Importer(args[0]);
      importer.go();
   }

   private void go() {
      try {
         File dir = new File(directory);

         doDir(dir);
      }
      catch (Throwable e) {
         e.printStackTrace();
      }
   }

   private void doDir(File dir) throws IOException, InterruptedException {
      File[] listFiles = dir.listFiles(new PomFilter());
      if (listFiles != null) {
         for (File pom : listFiles) {
            doPom(pom);
         }
      }

      File[] listDirs = dir.listFiles(new DirFilter());
      if (listDirs != null) {
         for (File subdir : listDirs) {
            doDir(subdir);
         }
      }
   }

   private void doPom(File pom) throws IOException, InterruptedException {
      File base = pom.getParentFile();
      String fileName = pom.getName();
      String jarName = fileName.substring(0, fileName.length() - 3) + "jar";
      File jar = new File(base.getAbsolutePath() + "/" + jarName);

      String exec = mvn + " deploy:deploy-file -DrepositoryId=" + repositoryId + " -Durl=" + url;
      if (jar.exists()) {
         exec += " -Dfile=\"" + jar.getAbsolutePath() + "\"";
      }
      else {
         exec += " -Dfile=\"" + pom.getAbsolutePath() + "\"";
      }
      exec += " -DpomFile=\"" + pom.getAbsolutePath() + "\"";
      exec(exec);

   }

   private void exec(String exec) throws InterruptedException, IOException {
      System.out.println(exec);
      Process p = Runtime.getRuntime().exec(exec);
      String line;
      BufferedReader bri = new BufferedReader(new InputStreamReader(p.getInputStream()));
      BufferedReader bre = new BufferedReader(new InputStreamReader(p.getErrorStream()));
      while ((line = bri.readLine()) != null) {
         System.out.println(line);
      }
      bri.close();
      while ((line = bre.readLine()) != null) {
         System.out.println(line);
      }
      bre.close();
      p.waitFor();
      System.out.println("Done.");
   }

   private class PomFilter implements java.io.FileFilter {

      @Override
      public boolean accept(File pathname) {
         return pathname.getName().endsWith(".pom");
      }
   }

   private class DirFilter implements java.io.FileFilter {

      @Override
      public boolean accept(File pathname) {
         return pathname.isDirectory();
      }
   }
}

WAS SOAPFault causing throws a WebServicesFault

2011-05-11T17:52:00.002+10:00

When returning a SOAPFault from a SOAP handler I saw this in Websphere Application Server's (6.1.0) console:

[11/05/11 18:20:51:654 EST] 00000047 WebServicesSe E com.ibm.ws.webservices.engine.transport.http.WebServicesServlet doPost WSWS3227E:  Error: Exception:
                                 WebServicesFault
 faultCode: 666
 faultString: myfaultstring
 faultActor: myhandler
 faultDetail: 

myfaultstring
 at com.ibm.ws.webservices.engine.xmlsoap.builders.WebServicesFaultProcessor.createFault(WebServicesFaultProcessor.java:420)
 at com.ibm.ws.webservices.engine.xmlsoap.SOAPFault.getFault(SOAPFault.java:615)
 at com.ibm.ws.webservices.engine.SOAPPart.getFault(SOAPPart.java:1097)
 at com.ibm.ws.webservices.engine.SOAPPart.getFault(SOAPPart.java:754)
 at com.ibm.ws.webservices.engine.Message.getFault(Message.java:935)
 ....

Or when throwing a custom SOAPFaultException:

[11/05/11 18:32:05:678 EST] 00000065 WebServicesSe E com.ibm.ws.webservices.engine.transport.http.WebServicesServlet doPost WSWS3227E:  Error: Exception:
                                 WebServicesFault
 faultCode: myWebServiceFunction
 faultString: my test
 faultActor: testActor
 faultDetail: 

my test
 at com.ibm.ws.webservices.engine.WebServicesFault.makeFault(WebServicesFault.java:189)
 at com.ibm.ws.webservices.engine.dispatchers.java.SessionDispatcher.invoke(SessionDispatcher.java:213)
 at com.ibm.ws.webservices.engine.PivotHandlerWrapper.invoke(PivotHandlerWrapper.java:248)
 ...

A SOAP fault is still returned to the client but you get a WebServicesFault exception on both ends. Digging into Websphere's with the help of a decompiler shows that this is caused simply by no fault detail being passed. Simply adding a fault detail with a text of "error" gets rid of this error.

Persisting ViewScoped beans across views in request

2010-11-01T14:40:00.002+11:00

I came across this problem when trying to deal with view scoped beans that you want to reuse in a different view, i.e. after clicking next in a wizard like page.

This was originally Discussed Here (now removed since Oracle merged Sun's forums).

The View Scope
There is a a brief summary of it here: JSF 2.0 New Feature Preview Series (Part 5) EDR1 Potpourri.
Basically view scoped values are attached to the current viewId. Values for the view scoped variables are stored in the map returned by UIViewRoot.getViewMap(boolean). Which is great for when your accessing the same view. However, it is cleared when the view is changed (e.g. from a navigation result) FacesContext.setViewRoot(javax.faces.component.UIViewRoot)

However, the flash scope was designed seemingly to solve this very problem.

Using the Flash Scope
Here's a write up of the Understanding the JSF 2.0 Flash scope. There's also some caveats shown here: The benefits and pitfalls of @ViewScoped.
So the logical step is to try it, :

public String doIt() {
   FacesContext.getCurrentInstance().getExternalContext().getFlash().put("thisBean", this);   return "next";
}

However, after some poking around, I discovered you can't re-store in FlashScope as ManagedBeanELResolver is before ScopedAttributeELResolver in the expression language resolver chain. Meaning that if you have a view "view1" with bean name "viewScopeBean1" and want to use the exact same bean in "view2" with bean name "viewScopeBean2", you can't.
The most you can do is store whatever data you need in the flash scope, then in the @PostConstruct of the new bean, pull in the values you need. Not an elegant solution but I'm sure messing around with the ELResolver chain could also do it but then you run the risk of it breaking else where.

f:convertNumber parses to double not BigDecimal

2010-10-12T18:19:00.001+11:00

The default behaviour of the f:convertNumber, implemented with NumberConverter, in converting a decimal String of "1.11", is to convert it to a double and then JSF converts that to a BigDecimal. Most of the time you won't notice this happening until you use CallableStatement.setBigDecimal to invoke a stored procedure. In MS SQL Server, you get the following error:

com.microsoft.sqlserver.jdbc.SQLServerException: Error converting data type nvarchar to decimal.

The cause of this is because inside the BigDecimal it stored "1100000000000000976996261670137755572795867919921875" as a result of converting the String to a double. This floating point error is the motivation for using BigDecimal in the first place. And of course because the SQL Server JDBC driver didn't know how to handle the BigDecimal properly.

Looking into ConvertNumber, it uses one of two converters (DecimalFormat or NumberFormat) depending on whether 'pattern' is used. In Java 5, they added setParseBigDecimal(boolean newValue) in order to yield the desired output.

You can't easily change the NumberConverter but you can very simply add your own. To do so, I grabbed the source of NumberConverter from Mojarra 2.0.2 and copied all of it into my own class: net.devgrok.BigDecimalConverter.

@FacesConverter(forClass = BigDecimal.class, value="bigdecimal")
public class BigDecimalConverter implements Converter, PartialStateHolder {

// ... existing code

  public Object getAsObject(FacesContext context, UIComponent component, String value) {

// ... existing code

      // Create and configure the parser to be used
      parser = getNumberFormat(locale);
      if (((pattern != null) && pattern.length() != 0) || "currency".equals(type))
      {
        configureCurrency(parser);
      }
      parser.setParseIntegerOnly(isIntegerOnly());
      boolean groupSepChanged = false;

      // BEGIN BigDecimal HACK
      if (parser instanceof DecimalFormat)
      {
        ((DecimalFormat) parser).setParseBigDecimal(true);
      }
      // END BigDecimal HACK
      
// ... existing code

  }

// ... existing code

}

Then just create a file META-INF/custom.taglib.xml:

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

<facelet-taglib xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facelettaglibrary_2_0.xsd"
    version="2.0">

    <namespace>http://devgrok.net/facestags</namespace>

    <tag>
        <tag-name>convertBigDecimal</tag-name>
        <converter>
            <converter-id>bigdecimal</converter-id>
        </converter>
    </tag>

</facelet-taglib>

And to use:

<?xml version="1.0" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<ui:composition xmlns="http://www.w3.org/1999/xhtml"
  xmlns:ui="http://java.sun.com/jsf/facelets"
  xmlns:h="http://java.sun.com/jsf/html"
  xmlns:f="http://java.sun.com/jsf/core"
  xmlns:fn="http://java.sun.com/jsp/jstl/functions"
  xmlns:c="http://java.sun.com/jsp/jstl/core"
  xmlns:dg="http://devgrok.net/facestags"
  >

  from goes here etc
  
  <h:inputText id="txtPrice" value="#{bean.item.price}">
    <dg:convertBigDecimal pattern="##0.00" />
  </h:inputText>
  
</ui:composition

Fixing my HTC Desire's wifi

2010-09-19T21:37:00.003+10:00

I recently did an Over The Air (OTA) update of my new HTC Desire from 2.09 to 2.10. The update all seemed to run correctly. However I soon noticed that the wifi wasn't working. Looking in settings, it showed wifi was disabled and when you try and enable it, you just get "error". Seems like other people have been getting this as well. I tried following their advice, reset the factory defaults but that didn't work. I couldn't get the recovery mode to load (in order to wipe the caches) - after some brief searching it appeared that this was due to root access so I gave up on that.
NOTE: it turns out I was doing it wrong. After selecting the recovery option a red triangle with an exclamation point is show. At which point you need to press volume+ and power to show the next menu.

Next I tried using latest RUU (2.10) but got Error 170 Usb Connection Error. One post mentions under 'update':

HTC has released a new Froyo OTA update. You can install this directly as an RUU. You may need the latest version of HTC Sync for this version. There appear to be a lot of issues installing this RUU due to drivers. I'd recommend you install the earlier version and update OTA to this version (you can do this manually too).

Using 1.21.405.2 gave me ERROR [131] customer id error. After some poking around, turns out that branded phones don't have a CID... That's what you get with a phone from Hong Kong I guess. However I'm not really sure if that's true...

Eventually I came across this thread which mentions fixing the wifi error with this update: Froyo (2.09.405.8) update - Windows not required. It all installed correctly and after starting it up, it ran through the first-time setup and this time said it detected a wireless network. Success! I didn't try the windows RUU for 2.09 so I'm not sure if that will work.

Next I downloaded the update manually as per the instructions here. The phone started downloading OTA_Bravo_HTC_EU_2.10.405.2-2.09.405.8_release567cypyi0feo4th5.zip so I'm using that instead of the one in the post.

This thread has a better discussion of the problem, with some simple instructions on how to revert and reload when a goldcard isn't needed.

Escaping a regex expression

2010-09-17T15:54:00.002+10:00

I was working on a project where I needed to dynamically generate a regular expression based on some user input but the string to search for needed to be escaped. Below is the quick and dirty way to do it:

/**
 * Utility function to replace regular expressions.
 *
 * @param input
 * @return
 */
private static String escapeRegex(String input)
{
    String special[] = { "\\", "[", "]", "^", "$", ".", "|", "?", "*", "+", "(", ")" };
    String val = input;
    for (String replace : special)
    {
        val = val.replace(replace, "\\" + replace);
    }

    return val;
}

Tomcat DBCP: Data source is closed

2010-09-14T17:08:00.003+10:00

After updating to the latest version of Tomcat I started getting the following error when redeploying a webapp from inside eclipse:

java.sql.SQLException: Data source is closed
    at org.apache.tomcat.dbcp.dbcp.BasicDataSource.createDataSource(BasicDataSource.java:1362)
    at org.apache.tomcat.dbcp.dbcp.BasicDataSource.getConnection(BasicDataSource.java:1044)

It seemed to be related to an updated version of DBCP that is used inside tomcat (I get Tomcat to manage my datasource). After tracing the code a bit I discovered it was because I called this, in my Filter.destroy() to do clean up:

((BasicDataSource) dataSource).close();

Older versions of Tomcat (6.0.26 and below), didn't care if you called it. When the webapp was reloaded, the datasource still worked. But as of 6.0.28, the newer version of DBCP seems to cause problems.

So if you want to clean up after the webapp, use the removeAbandoned attribute in the Tomcat Configuration on the datasource, that way DBCP just cleans up after itself.

NOTE: I'm using the tomcat-dbcp.jar from Tomcat 7 in my Tomcat 6 instance so that I'm able to use the JDBC 4 functionality. Hence the link to the new documentation, Tomcat 6 Configuration also has it though.

Portable java environments on windows

2010-09-08T08:15:00.003+10:00

I always seem to be copying my development environment between PCs and latops which end up being time consuming. Its not the size of the data, its the number of small files (mainly javadoc & java source) that slow the whole process down. I already store the source code and workspace for my clients in a TrueCrypt Volume, to prevent my code being stolen if someone were to get hold of my laptop.

All the other necessary files I need for development; such as libraries, jdk, tomcat/jboss, elcipse etc; are stored on my hard drive. In some cases on different drive letters on different computers. So to simplify this I wanted to store them in a similar way to a TrueCrypt volume but without the overhead of encryption and the hassle of mounting it. After some poking around I remember that Windows 7 came with built-in support for creating and mounting Virtual Hard Disk (VHD) straight from the Storage Manager. The VHD are used by Virtual PC. For those running Vista, Virtual PC 2007 should support this.

For windows 7, you can easily mount an image using the admin interfaces or even create a shourtcut/bat script to mount it. However I wanted the image mounted on start up so it was ready to use. I eventually came across this neat utility (vhdattach) to add shell extension to mount an image with the option to mount at startup. Vista has this alternative.

Now all I need to do to swap PC's is to copy my TrueCrypt volume and my VHD across, mount them on the same letters and done! No need to change paths etc.

EL Coerces empty/null to ZERO

2010-06-06T11:10:00.000+10:00

I recently came across a problem where I was expecting a null value to be populated into one of my JSF managed beans on submit. After digging through the entire stack, I found out this was deliberate.
This bug was introduced into Tomcat 6.0.16, as a consequence of implementing the EL spec to the letter.
The option to disable this change at command line was added in 6.0.17:

-Dorg.apache.el.parser.COERCE_TO_ZERO=false

A patch in Tomcat 6.0.24 was added to allow you to change it at run time:

System.getProperties().put("org.apache.el.parser.COERCE_TO_ZERO", "false");

This problem also directly occurs in JSF, as it uses an EL engine as well. There's a patch for 1.2_08-b01 but it is happening in 2.0.2. But the above fix seems to work.

Request to change the JSP Spec

As per chapter 1.18.2 and 1.18.3 of EL spec, EL coerces null values to non-null
values such as empty String or (Long) 0 or (Boolean) false. This behaviour is in
almost all cases unwanted when the type is not a primitive.

After some more digging also came across this discussion at stackoverflow.

A simple way to Inject Guice into JSF (Mojarra)

2010-06-01T14:30:00.003+10:00

Previously I have been using GuiceSF to inject the JSF managed beans which extends the Mojarra's implementation of ELResolver (ManagedBeanELResolver). This was bit of a hack but it was relatively simple to implement.
In upgrading to newer version of JSF, I had to manually tweak it to keep it in line with the new features in the spec which took a fair amount of debug stepping. So when JSF 2 came out I looked around for a way to do it which still used the implementation's bean creation and handling but also injected it with Guice.

After digging around in the injection code in Mojarra, I saw how simple it would be to extend the provided Tomcat injection (which injects stuff for the @Resource and @EJB etc annotations).

This solution first requires the injection provider be specified in web.xml:

<context-param>
   <description>JSF Injection provider</description>
   <param-name>com.sun.faces.injectionProvider</param-name>
   <param-value>net.devgrok.jsf.Tomcat6GuiceInjectionProvider</param-value>
</context-param>

Next extend the Tomcat injector:

package net.devgrok.jsf;

import javax.faces.FacesException;
import javax.servlet.ServletContext;

import org.apache.AnnotationProcessor;

import com.google.inject.Injector;
import com.sun.faces.spi.InjectionProviderException;
import com.sun.faces.vendor.Tomcat6InjectionProvider;

/**
 * Based on {@link com.sun.faces.vendor.Tomcat6InjectionProvider}. Injects using Guice for JSF.
 * 
 * @author Chris Watts
 */
public class Tomcat6GuiceInjectionProvider extends Tomcat6InjectionProvider
{

 private ServletContext servletContext;

 public Tomcat6GuiceInjectionProvider(ServletContext servletContext)
 {
  super(servletContext);
  this.servletContext = servletContext;
 }

 public void inject(Object managedBean) throws InjectionProviderException
 {
  try
  {
   getProcessor().processAnnotations(managedBean);
   getInjector().injectMembers(managedBean);
  }
  catch (Exception e)
  {
   throw new InjectionProviderException(e);
  }
 }

 private AnnotationProcessor getProcessor()
 {
  return ((AnnotationProcessor) servletContext.getAttribute(AnnotationProcessor.class.getName()));
 }
 
 protected Injector getInjector()
 {
  Injector injector = (Injector) servletContext.getAttribute(Injector.class.getName());
  if (injector == null)
   throw new FacesException("Guice injector not found, verify your web.xml file for mapping GuiceContextListener");
  return injector;
 }
}

Converting custom JSF 1 components to JSF 2

2010-05-11T00:11:00.032+10:00

These are just some observations/tips I made when converting my JSF 1 components to JSF 2.

Simpler .taglib.xml

The taglib definition changes from mycomponent.tld to mycomponent.taglib.xml. The xml inside the new file is similar but with some changes (i.e. <name> becomes <tag-name>). The major simplification is that attributes no longer need to be defined. Just the tag-name and component-type.

<tag>
 <name>menuItem</name>
 <tag-class>net.devgrok.component.MenuItemTag</tag-class>
 <body-content>JSP</body-content>
 <attribute>
  <name>value</name>
  <required>false</required>
  <deferred-value>
   <type>java.lang.String</type>
  </deferred-value>
 </attribute>
</tag>

Becomes:

<tag>
 <tag-name>menuItem</tag-name>
 <component>
  <component-type>net.devgrok.MenuItem</component-type>
 </component>
</tag>

And the newly created xml file is referenced as a context-param in web.xml (it could just be located under WEB-INF):

<context-param>
   <description>list of facelet libraries</description>
   <param-name>javax.faces.FACELETS_LIBRARIES</param-name>
   <param-value>/WEB-INF/classes/META-INF/custom.taglib.xml</param-value>
</context-param>

Component Class

The component class is annotated with: @FacesComponent(value = "value from mycomponent.taglib.xml"). Then for each property create a setter (I also create a getter) that sets the value as evaluated at the apply request values phase. I use an enum as the key to store attributes against.

@FacesComponent(value = "net.devgrok.MenuItem")
public class MenuItem extends UIComponentBase {
 private enum PropertyKeys {
  value;
  String toString;

  PropertyKeys(String toString)  {
   this.toString = toString;
  }

  PropertyKeys()  {
  }
 }
 
 public void setValue(Object value) {
  getStateHelper().put(PropertyKeys.value, value);
 }
 
 public Object getValue()
 {
  return getStateHelper().get(PropertyKeys.value);
 }

No need for tag handler

As facelets is fully integrated into JSF 2 and it is not driven by JSPs, the need to create a class for every component that extends com.sun.facelets.tag.TagHandler or javax.faces.webapp.UIComponentELTag has been removed. For cases where you need to perform special actions after the values have been populated, create a simple class extending javax.faces.view.facelets.ComponentHandler. There are some instructions here: JSF2 Facelet Tag Handlers.

Some problems

Had some trouble with tag attributes, which I worked around by using the above getter instead of using (String) this.getAttributes().get("name");

ClassNotFoundException destroying a session in Tomcat

2010-02-17T15:08:00.001+11:00

When a session was being expired (either through a timeout, or via using the Tomcat Manager to manually destroy them) that contained an EJB I was getting a ClassNotFoundException. The stack trace when killing from the manager was:

java.lang.RuntimeException: Specified calling class, net.devgrok.MyEjbRemote could not be found for WebappClassLoader
  delegate: false
  repositories:
----------> Parent Classloader:
org.apache.catalina.loader.StandardClassLoader@70cb6009

 at org.jboss.ejb3.common.lang.SerializableMethod.getClassFromName(SerializableMethod.java:311)
 at org.jboss.ejb3.common.lang.SerializableMethod.getClassType(SerializableMethod.java:282)
 at org.jboss.ejb3.common.lang.SerializableMethod.toMethod(SerializableMethod.java:233)
 at org.jboss.ejb3.common.lang.SerializableMethod.toMethod(SerializableMethod.java:220)
 at org.jboss.ejb3.proxy.impl.handler.session.SessionProxyInvocationHandlerBase.invoke(SessionProxyInvocationHandlerBase.java:182)
 at org.jboss.ejb3.proxy.impl.handler.session.SessionProxyInvocationHandlerBase.invoke(SessionProxyInvocationHandlerBase.java:164)
 at net.devgrok.JndiRemoteProxyInvocationHandler.invoke(JndiRemoteProxyInvocationHandler.java:55)
 at $Proxy15.logout(Unknown Source)
 at org.apache.catalina.session.StandardSession.expire(StandardSession.java:702)
 at org.apache.catalina.session.StandardSession.expire(StandardSession.java:660)
 at org.apache.catalina.session.StandardSession.invalidate(StandardSession.java:1113)
 at org.apache.catalina.session.StandardSessionFacade.invalidate(StandardSessionFacade.java:150)
 at org.apache.catalina.manager.HTMLManagerServlet.invalidateSessions(HTMLManagerServlet.java:822)
 at org.apache.catalina.manager.HTMLManagerServlet.doSessions(HTMLManagerServlet.java:690)
 at org.apache.catalina.manager.HTMLManagerServlet.doGet(HTMLManagerServlet.java:128)
 at org.apache.catalina.manager.HTMLManagerServlet.doPost(HTMLManagerServlet.java:164)
 at javax.servlet.http.HttpServlet.service(HttpServlet.java:637)
 at javax.servlet.http.HttpServlet.service(HttpServlet.java:717)
 ...
 at java.lang.Thread.run(Thread.java:619)
Caused by: java.lang.ClassNotFoundException: net.devgrok.MyEjbRemote
 at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1387)
 at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1233)
 at java.lang.Class.forName0(Native Method)
 at java.lang.Class.forName(Class.java:247)
 at org.jboss.ejb3.common.classloader.PrimitiveAwareClassLoader.findClass(PrimitiveAwareClassLoader.java:105)
 at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
 at java.lang.ClassLoader.loadClass(ClassLoader.java:248)
 at org.jboss.ejb3.common.lang.SerializableMethod.getClassFromName(SerializableMethod.java:307)
 ... 32 more

After some investigating I discovered the current thread's ClassLoader was incorrect. So I created a HttpSessionListener to swap the ClassLoader, unload the session and put the ClassLoader back.

public class SessionLifecycleEventListener implements HttpSessionListener
{
   private static final Logger log = LoggerFactory.getLogger(SessionLifecycleEventListener.class);
   public void sessionDestroyed(HttpSessionEvent evt)
   {
      HttpSession session = evt.getSession();
      //remember class loader
      ClassLoader currentLoad = Thread.currentThread().getContextClassLoader();
      try
      {
         //set classloader to be the webapp's
         ClassLoader webApp = this.getClass().getClassLoader();
         Thread.currentThread().setContextClassLoader(webApp);
         
         //clear all the session objects now
         Enumeration<String> names = session.getAttributeNames();
         while (names.hasMoreElements())
         {
            String name = names.nextElement();
            session.removeAttribute(name);
         }
      }
      catch (RuntimeException e)
      {
         log.error("closeEjbSession caught exception", e);
      }
      finally
      {
         //restore classloader
         Thread.currentThread().setContextClassLoader(currentLoad);
      }
      
   public void sessionCreated(HttpSessionEvent evt)
   {
   }
}

Using RichFaces to give versioned URL's

2010-02-11T19:27:00.003+11:00

RichFaces has some nice components that can load scripts and styles when placed anywhere in the xhtml page and automatically inserts them into the header at render time. For example a footer could say it requires stylesheet, after you've already defined a header.

The tags are pretty simple there is the style loader, loadStyle:

<afj:loadstyle src="/css/test.css"></afj:loadstyle>

And the script loader, loadScript:

<afj:loadscript src="/javascript/test.js">

The src can be a path be:

Relative to the current page.
Path relative to the context if starting with a slash.
Or loaded by RichFaces resource framework
Using "resource:///path/to/file"

Now, the problem most web developers always face is that of caching. If you disable caching then the site is slow for the user and your bandwidth is used up. If you enable caching and release a new version, how do you clear the user's and ISP's cache so they can see your changes?

RichFaces already deals with this by creating virtual URL's for all their resources served (the static javascript files and the generated css files and images). It prepends "afj/g/[version]" to the url's. For example:

<script src="/myapp/jsf/a4j/g/3_3_2.SR1jquery.js" type="text/javascript">

Where myapp is the name of the context and I have a mapping to the faces servlet for /jsf/*. This gets prepended to all resources served through the framework, even ones from your war.

This neat little feature can be used to version your own deployments, so that after each build a new URL is generated.

If your using maven its simple.
First add this to your web.xml:

<!-- 
  not used, but needs to be set
-->
<context-param>
  <param-name>org.ajax4jsf.RESOURCE_URI_PREFIX</param-name>
  <param-value>a4j/${project.version}-r${buildNumber}</param-value>
</context-param>
<!-- 
  the prefix used by richfaces for global cached resources
-->
<context-param>
  <param-name>org.ajax4jsf.GLOBAL_RESOURCE_URI_PREFIX</param-name>
  <param-value>a4j/g/${project.version}-r${buildNumber}</param-value>
</context-param>
<!-- 
  the prefix used by richfaces for session cached resources
-->
<context-param>
  <param-name>org.ajax4jsf.SESSION_RESOURCE_URI_PREFIX</param-name>
  <param-value>a4j/s/${project.version}-r${buildNumber}</param-value>
</context-param>

Next you'll need to add the buildnumber plugin:

<build>
   <plugins>
      <plugin>
         <groupId>org.codehaus.mojo</groupId>
         <artifactId>buildnumber-maven-plugin</artifactId>
         <executions>
            <execution>
               <phase>validate</phase>
               <goals>
                  <goal>create</goal>
               </goals>
            </execution>
         </executions>
         <configuration>
            <doCheck>false</doCheck>
            <doUpdate>false</doUpdate>
         </configuration>
      </plugin>
      <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-war-plugin</artifactId>
         <configuration>
            <warSourceDirectory>WebContent</warSourceDirectory>
            <webXml>src/PROD/web.xml</webXml>
            <filteringDeploymentDescriptors>true</filteringDeploymentDescriptors>
            <archive>
               <manifest>
                  <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
               </manifest>
               <manifestEntries>
                  <Implementation-Build>${buildNumber}</Implementation-Build>
               </manifestEntries>
            </archive>
         </configuration>
      </plugin>

If your using eclipse to do development then you'll probably want to have 2 web.xml files. One that eclipse can read with the filtering (property subsititution turned off) and one for production builds.
In

Safari removed javascript API

2010-02-04T18:55:00.001+11:00

In the latest version of Safari (WebKit) they have removed some deprecated javascript API & tags which can cause problems with older code. This is my attempt to keep track of them so I can search through the code and change it to use a newer method.

Here is a list of what works in Firefox 3 or Internet Explorer but not Safari:

document.[form name] where [form name] matches the element <form name='[form name]'>
Replacement:Use document.getElementById() instead
document.embeds
Replacement:
Use document.getElementById() instead
Form element's id defaulted to their name
Replacement:
Manually specify the id
<applet> tag
Replacement:
<object> tag

That's it for the moment but I'll keep updating the list as I find them.

Building your own jbossall-client.jar

2010-02-02T00:43:00.003+11:00

The newer versions of JBoss (I'm using 5.1.0 GA) very annoyingly have all the client jars split into at least 47 separate jars! Which is a bit rude when you consider the total number of jars they expect you to copy into your tomcat/lib dir is a whopping 93.

JBoss are declined to make the client jars into a single file again as its meant to make it easier to upgrade... That's arguable but still leaves us with all these files to copy around. After searching the net I've found a rather nice solution which I have adapted below.
The way I use it is as follows. I combine all jboss*.jar files into a single jar and then copy the additional dependencies.

Create a directory an empty directory and put the build.xml in it and create a /jboss dir. Copy all jboss jboss*.jar from jboss-5.1.0.GA/client.

Create a /build.xml:

<project default="combine">
   <property name="temp.dir" value="unpacked" />
   <property name="lib.dir" value="jboss" />
   <property name="jar.filename" value="jbossall-client.jar" />

   <target name="clean">
      <delete dir="${temp.dir}" quiet="true" />
      <delete file="${base.dir}/${jar.filename}" quiet="true" />
   </target>
   
   <target name="unjar.jar">
      <unjar dest="${temp.dir}">
         <patternset>
            <exclude name="META-INF/MANIFEST.MF" />
         </patternset>
         <fileset dir="${lib.dir}">
            <include name="**/*.jar" />
         </fileset>
      </unjar>
   </target>


   <target name="combine" depends="unjar.jar">
      <jar jarfile="${basedir}/${jar.filename}"
         basedir="${temp.dir}" update="true"
         compress="false">
      </jar>
   </target>
</project>

It will extract and recombine the jar files for you.

The dependencies I also copy across are:

concurrent.jar
ejb3-persistence.jar
hibernate-annotations.jar
javassist.jar
jmx-client.jar
jmx-invoker-adaptor-client.jar
jnp-client.jar
trove.jar
xmlsec.jar

Automake unable to detect vendor on RedHat EL5

2010-02-01T15:26:00.001+11:00

After chasing down some build problems with subversion 1.6.9 on EL5 I was noticing that it was detecting the system as x86_65-unknown-linux-gnu. Worried that it would cause me later problems I started digging through the configure script. It lead me to the build/config.guess script.
After spending too long searching the net and trying to resolve the issue, I just did this:

subversion-1.6.9>cp /usr/lib/rpm/config.guess ./build/config.guess

Basically overriding the one that came with the distro with redhat's hack.

Using a NavigiationHandler to do HTTP/HTTPS switching

2010-01-16T13:07:00.003+11:00

In a project I was working on, we wanted the log in page and anything to do with payment to be secure using HTTPS, whilst the majority of the site would be unsecure using HTTP. JSF 1.2 doesn't really give you anyway of doing this other than manually specifying the full url for every single link and button on the site. This removes a lot of the flexibility and simplicity of JSF. I came up with a pretty good solution. For any link or action that you know will switch between secure and unsecure, which isn't that hard to know (if you design the site with that in mind), then you configure it to be a redirect. Then you create your own navigation handler which applies rules you create yourself, to determine which parts should be secure or not.

This is a very simple solution that when a redirect occurs, it checks the path of the destination page (its viewId). If it starts with "/secure" it gives a full HTTPS url and for all others, it gives a full HTTP url. To activate it, have a navigation rule with a redirect. e.g. a login button with a result "userLogin":

<navigation-case>
 <from-outcome>userLogin</from-outcome>
 <to-view-id>/secure/login.xhtml</to-view-id>
 <redirect/>
</navigation-case>
<navigation-case>
 <from-outcome>home</from-outcome>
 <to-view-id>/index.xhtml</to-view-id>
 <redirect/>
</navigation-case>

Then on successful login return result "home" to redirect back to HTTP.

Next you'll need to create and configure your own navigation handler. The easiest way is to copy the entire contents of the mojarra NavigationHandlerImpl and change one line. In the handleNavigation function the line String newPath = viewHandler.getActionURL(context, caseStruct.viewId); is replaced as shown below:

public void handleNavigation(FacesContext context, String fromAction, String outcome) {

   // ...
   
   if (caseStruct != null) {
      ViewHandler viewHandler = Util.getViewHandler(context);
      assert (null != viewHandler);

      if (caseStruct.navCase.hasRedirect()) {
         // perform a 302 redirect.
         // ---- start change ---
         String newPath = prependSecure(context, viewHandler, caseStruct.viewId);
         // ---- end change -----
         
   //....
}

Download the full source here.

Below is the additional code to support to prependSecure function, that builds up a full url with scheme for the page being redirected to.

private static final String SCHEME_HTTP = "http";
private static final String SCHEME_HTTPS = "https";
private static final int HTTPS_DEFAULT_PORT = 443;
private static final int HTTP_DEFAULT_PORT = 80;
private static final String PREFIX_SECURE = "/secure/";

private String prependSecure(FacesContext context, ViewHandler viewHandler,
      String viewId) {
   boolean isSecure = (viewId != null && (viewId.startsWith(PREFIX_SECURE)));

   String prefix = getServerUrlForceScheme(context, isSecure);

   return prefix + viewHandler.getActionURL(context, viewId);
}

public static String getServerUrlForceScheme(FacesContext context,
      boolean secure) {
   String scheme;
   int defaultPort;
   if (secure) {
      scheme = SCHEME_HTTPS;
      defaultPort = HTTPS_DEFAULT_PORT;
   } else {
      scheme = SCHEME_HTTP;
      defaultPort = HTTP_DEFAULT_PORT;
   }

   HttpServletRequest request = (HttpServletRequest) context
         .getExternalContext().getRequest();

   int port;
   //use current port if known (ideally make this configuration driven)
   if ((!SCHEME_HTTPS.equalsIgnoreCase(request.getScheme()) && !secure)
         || (!SCHEME_HTTP.equalsIgnoreCase(request.getScheme()) && secure))
      port = request.getServerPort();
   else
      port = defaultPort;

   String basePath = scheme + "://" + request.getServerName()
         + (defaultPort == port ? "" : ":" + port);

   return basePath;
}

Updating the nextval of all sequences in PostgreSQL

2010-01-12T23:13:00.001+11:00

If you've been doing SQL level inserts for testing purposes, then when you go to use the sequences then they will have a nextval that already exists in your table.

So below is a script which updates the nextval for all fields that were created using bigserial/serial:

/* Updates all the sequences to have a next value of max+1 excluding the list passed */
CREATE OR REPLACE FUNCTION fn_fixsequences(excludes text) RETURNS integer AS
$BODY$
DECLARE
themax BIGINT;
mytables RECORD;
num integer;
BEGIN
 num := 0;
 FOR mytables IN 
  select relname, ns.nspname, a.attname, pg_get_serial_sequence(c.relname, a.attname) as seq
  FROM pg_catalog.pg_attribute a INNER JOIN 
   pg_catalog.pg_class c ON c.oid=a.attrelid
    inner join pg_catalog.pg_attrdef d
    on d.adrelid = a.attrelid AND d.adnum = a.attnum AND a.atthasdef
       LEFT JOIN pg_catalog.pg_namespace ns ON ns.oid = c.relnamespace
  WHERE 
    pg_catalog.pg_table_is_visible(c.oid)
   and a.attnum > 0 AND NOT a.attisdropped  and atttypid=20
   and relname not like 'pg_%' and relname not like excludes
   and ns.nspname not in ('information_schema', 'pg_catalog')
   and c.relkind='r'
   and not pg_get_serial_sequence(c.relname, a.attname) is null
 LOOP
      EXECUTE 'SELECT MAX('||mytables.attname||') FROM '||mytables.nspname||'.'||mytables.relname||';' INTO themax;
      IF (themax is null OR themax < 0) THEN
       themax := 0;
      END IF;
      themax := themax +1;
      EXECUTE 'ALTER SEQUENCE ' || mytables.seq || ' RESTART WITH '||themax;
      num := num + 1;
  END LOOP;
 
  RETURN num;
 
END;
$BODY$
LANGUAGE 'plpgsql' VOLATILE;
COMMENT ON FUNCTION fn_fixsequences() IS 'Updates all the sequences to have a next value of max+1 excluding the list passed';

Getting JBoss Scheduler working

2010-01-09T00:09:00.000+11:00

When using the @Service annotation together with the scheduler has given me no end of trouble so I'd like to share my working configuration.

It took me a while to get the objectName right. If your not using @Service(objectName='name') but instead using @Service(name='name') then the final object name is not the same as what they imply at EJB Extensions Help.
Instead I'd recommend going into the JMX console of the running server and searching for it manually, listed under 'jboss.j2ee' for the name you've specified AND type=ManagementInterface.

As well as defining the @Service, you'll also need to define the @Management.

@Management(SampleServiceMBean.class)
@Service(name = SampleServiceMBean.SERVICE_NAME)
public class SampleServiceMBean implements SampleService
{
 public final static String SERVICE_NAME = "SampleServiceMBean";
 
 public void process(ObjectName name, Date date)
 {
  log.info("process {} {}", name, date);
 }

Then create a file the appropriate place
e.g. MyEar.ear/MyEjb.jar/META-INF/myscheduler-service.xml:

<?xml version="1.0" encoding="UTF-8"?>
<server>
 <mbean code="org.jboss.varia.scheduler.Scheduler" name=":service=MyScheduler">
  <attribute name="StartAtStartup">true</attribute>
  <attribute name="SchedulableMBean">jboss.j2ee:ear=MyEar.ear,jar=MyEjb.jar,name=SampleServiceMBean,service=EJB3,type=ManagementInterface</attribute>
  <attribute name="SchedulableMBeanMethod">process( SCHEDULER_NAME, DATE )</attribute>
  <attribute name="InitialStartDate">NOW</attribute>
  <attribute name="SchedulePeriod">60000</attribute>
  <attribute name="InitialRepetitions">10</attribute>
  <attribute name="FixedRate">true</attribute>
    <depends>
      <mbean code="javax.management.timer.Timer" name="jboss:service=Timer"/>
    </depends>
 </mbean>
</server>

The parameter list threw me off for a while. If you get errors like java.lang.IllegalArgumentException: Unable to find operation processPending(javax.management.ObjectName,java.util.Date), the the key is the argument list (obviously).

Good luck.

Disabling RichFaces FacesBeanValidator

2010-01-07T20:08:00.003+11:00

If you use the rich:ajaxValidator, for example:

<rich:ajaxValidator event="onblur" />

It automatically adds a FacesBeanValidator to the components list of validators. If you don't have javax.validation or Hibernate Validator setup then you'll get the following exception:

2010-01-07 00:29:19,889 [http-8443-1] WARN  org.richfaces.validator.ObjectValidator - Hibernate Validator could not be instantiated, use stub instead
javax.validation.ValidationException: Unable to find a default provider
 at javax.validation.Validation$GenericBootstrapImpl.configure(Validation.java:248)
 at javax.validation.Validation.buildDefaultValidatorFactory(Validation.java:115)
 at org.richfaces.validator.BeanValidator.(BeanValidator.java:34)
 at org.richfaces.validator.ObjectValidator.createInstance(ObjectValidator.java:54)
 at org.richfaces.validator.ObjectValidator.getInstance(ObjectValidator.java:85)
 at org.richfaces.validator.FacesBeanValidator.validate(FacesBeanValidator.java:103)
 at org.richfaces.component.html.HtmlInputText.validateValue(HtmlInputText.java:52)

The way I'd like to be able to do it is:

<managed-bean>
  <description>
   Override RichFaces dependance on hibernate validator and validation api. This stops boot up exceptions (errors once).
  </description>
  <managed-bean-name>org.richfaces.validator.HibernateValidator</managed-bean-name>
  <managed-bean-class>org.richfaces.validator.NullValidator</managed-bean-class>
  <managed-bean-scope>application</managed-bean-scope>
 </managed-bean>

However, unless the bean is accessed by an EL expression like #{applicationScope['org.richfaces.validator.HibernateValidator']}, then it won't be instantiated and added to the application map.

So the only other solution is to set it with code in a ContextListener:

public void contextInitialized(ServletContextEvent event) {
  event.getServletContext().setAttribute(
    org.richfaces.validator.ObjectValidator.VALIDATOR_PARAM, 
    new org.richfaces.validator.NullValidator());
}

A bit of work just to hide an exception... And all this because I was chasing a red herring.

Friendly paths to access dynamic JSF content

2009-12-02T11:26:00.030+11:00

JSF 1 is HTTP POST based and, as such, makes it hard to generate friendly/RESTful URLs that are meaningful to the user. Try to serve something like a content management system (CMS) using JSF and you immediately run into problems. However if you write a custom ViewHandler, you can translate the virtual url, such as /page/about/contactUs, into a physical page (view), e.g. /dynamicContent.xhtml.

All cases where the ViewHandler references the viewId (which is just the full filename of the page its executing/referencing), need to be mapped correctly so that JSF opens the page that exists, while the user sees the content specified by the URL that maps to a database for example.

Below is the view handler that wraps around the Facelets view handler to provide the described functionality.:

/**
 * View Handler that wraps around first Facelets then the default handler, to translate the virtual address of the content page to the physical xhtml
 * page that will serve it.
 * 
 * @author Chris Watts
 */
public class ParameterisedPathViewHandler extends ViewHandlerWrapper
{
   /** servletmapping for physical page */
   private static final String PAGE_URL = "/dynamicPage.jsf";
   /** physical page file name */
   private static final String PAGE_FILE_NAME = "/dynamicContent.xhtml";
   /** servletmapping prefix for served pages */
   private static final String PAGE_PREFIX = "/page";
   /** richfaces exclusion */
   private static final String A4J_PREFIX = "/page/a4j/";
   private ViewHandler wrappedHandler;

   /**
    * Constructor taking the previous view handler in the chain (called by JSF implementation).
    * @param defaultHandler previous handler in the chain
    */
   public ParameterisedPathViewHandler(ViewHandler defaultHandler)
   {
      //put facelets in the chain.
      //If using richfaces the context param org.ajax4jsf.VIEW_HANDLERS
      //should be set to: "com.sun.facelets.FaceletViewHandler,net.devgrok.jsf.ParameterisedPathViewHandler"
      //and the below code commented out.

      FaceletViewHandler faceletHandler = new FaceletViewHandler(defaultHandler);
      this.wrappedHandler = faceletHandler;
//      this.wrappedHandler = defaultHandler; // to use richfaces chaining
   }

   @Override
   protected ViewHandler getWrapped()
   {
      return wrappedHandler;
   }

   @Override
   public UIViewRoot createView(FacesContext context, String viewId)
   {
      return wrappedHandler.createView(context, resolveUrl(context, viewId));
   }

   private boolean isContentPage(FacesContext context, String viewId)
   {
      String servlet = context.getExternalContext().getRequestServletPath();
      if (servlet == null || servlet.length() == 0)
         return false;
      if (servlet.startsWith(A4J_PREFIX))
         return false;
      return servlet.startsWith(PAGE_PREFIX);
   }

   //Determine what physical page will serve the request.
   private String resolveUrl(FacesContext context, String viewId)
   {
      if (!isContentPage(context, viewId))
         // not content page so use original viewId
         return viewId;

      //store pageId in request map for later retrieval
      Map<String, Object> requestMap = context.getExternalContext().getRequestMap();
      String pageId;
      //pageId is the document to be served
      pageId = viewId.substring(1);
      requestMap.put("pageId", pageId);
      return PAGE_FILE_NAME;
   }

   //If is one of the dynamic content pages then actual url of xhtml file to handle it.
   @Override
   public String getActionURL(FacesContext context, String viewId)
   {
      if (isContentPage(context, viewId))
         return getDynamicPageUrl(context, viewId);
      else
         return wrappedHandler.getActionURL(context, viewId);
   }

   private String getDynamicPageUrl(FacesContext context, String viewId)
   {
      return context.getExternalContext().getRequestContextPath() + PAGE_URL;
   }

   @Override
   public UIViewRoot restoreView(FacesContext context, String viewId)
   {
      return wrappedHandler.restoreView(context, resolveUrl(context, viewId));
   }
}

Resources

Download the source containing the above class and example usage.

Undeploying Google Guice jar file locked

2009-11-19T13:33:00.002+11:00

When trying to undeploy an webapp that uses Google Guice from an webapp server like Tomcat, you may notice that it doesn't undeploy properly. The problem seems to be related to com.google.inject.internal.Finalizer, which is a Thread created to clean up after Guice is finished. However the thread doesn't stop properly.

My solution is to modify this class (by just adding that individual source file to the project as I don't want to rebuild the whole project) adding a stop method that can be call from a ServletContextListener.contextDestroyed().

My modified Finializer:

private boolean stop = false;

/**
 * Loops continuously, pulling references off the queue and cleaning them up.
 */
//  @SuppressWarnings("InfiniteLoopStatement")
@Override
public void run() {
  try {
    while (!stop) {
      try {
        cleanUp(queue.remove());
      } catch (InterruptedException e) { /* ignore */ }
    }
  } catch (ShutDown shutDown) { /* ignore */ }
}

public void stopThread() {
  this.stop = true;
  this.interrupt();
}

Then from listener (in this case I've modified GuiceContextListener from GuiceSF, which seems to have now disappeared but you could write your own from scratch), you need to stop the thread:

public class GuiceContextListener implements ServletContextListener {
  public void contextDestroyed(ServletContextEvent contextEvent)
  {
    ServletContext context = contextEvent.getServletContext();
    //start custom code
    
    //first use the GuiceyFruit Injectors class to notify all objects their being destroyed
    try
    {
      Injector injector = getInjector(context);
      Injectors.close(injector);
    }
    catch (CloseFailedException e)
    {
      LOG.log(Level.SEVERE, "Guicesf finhised", e);
    }
    
    ThreadGroup root = Thread.currentThread().getThreadGroup().getParent();
    while (root.getParent() != null)
    {
      root = root.getParent();
    }
  
    //now find the thread
    Thread thread = getThread(root, Finalizer.class.getName());
    if (thread == null)
    {
      LOG.log(Level.INFO, "finalizer not found");
    }
    else
    {
      LOG.log(Level.INFO, "Stopping finalizer");
      callMethod(thread, "stopThread");
    }
    //end custom code
    context.removeAttribute(Injector.class.getName());
    LOG.log(Level.INFO, "Guicesf finished");
  }

  private static Thread getThread(ThreadGroup group, String name)
  {
    int num = group.activeCount();
    Thread[] threads = new Thread[num * 2];
    num = group.enumerate(threads, true);
    for (int i = 0; i < num; i++)
    {
      Thread thread = threads[i];
      if (thread == null)
      {
      }
      else if (thread.getName().equals(name))
      {
        return thread;
      }
    }
    return null;
  }

  private static void callMethod(Object obj, String methodName)
  {
    try
    {
      Class clazz = obj.getClass();
      Method method = clazz.getMethod(methodName, (Class[]) null);
      method.invoke(obj, (Object[]) null);
    }
    catch (Exception e)
    {
      LOG.log(Level.SEVERE, "callMethod caught exception", e);
    }
  }

Download the modified source: undeploy_guice-src.zip

Other people have noticed the problem, which trace it to problems with FinalizableReferenceQueue. There is an attached patch which resolves the issue of having to manually stop the thread.

Actions not being called when using 2 view tags

2009-10-25T01:46:00.006+11:00

I had a problem where a command button's action was not being called on the managed bean.

When using tiles inside JSF, you may have it set up so that you have a template.jsp and a body.jsp.
The template.jsp, using tiles inserts body.jsp.

template.jsp defines a <f:view> tag as per normal.
Inside body.jsp, whilst you don't technically need a <f:view> tag, you may get some component (namely f:phaseListener) complaining about not having a view root, so you does it asks and defines the <f:view> at the start of the file.

You load up the page, everything renders correctly and you click a submit button. The form validation errors appear as normal, so you fill in some values and click submit again.
This time, NOTHING.
So you try turning on all the logging and still nothing seems wrong.

This happened to me. I wasted quiet a few hours on this one: working out how to log things correctly using eclipse/tomcat and get Java Util Logging working etc. After a ton of breakpoints, it appeared that there were no 'events' cued for the view root to invoke in the Invoke Application Phase. Some more breakpoints showed that the button was being decoded and an event was being added to the queue. However it wasn't in the main view root. Strange.

After some pondering I decided that the problem must be that the included page wasn't sending the events up.

So the solution:
When using tiles, inside the included page use <f:subview id="'body'"> not <f:view>.

However, this means that you can't use a <f:phaseListener> tag in the included page.

I was using mojarra-1.2_12.

Calling JSF actions by URL

2009-09-02T08:21:00.004+10:00

In JSF 1, there is no provided functionality to invoke an action (by this I mean a java function, not a JSF action invoked by a component). JSF 2 adds functionality to support this, through f:viewParam / f:event and the PreRenderViewEvent.

However in JSF 1, you can bind a phase listener to a specific page using the f:phaseListener tag to call the code before the Render Phase. To make sure that the code is only called when the page is access via the url and not from a postback caused by a component you can use the function added in JSF 1.2: ResponseStateManager.isPostback(FacesContext context).

First off we configure the phase listener in the page (action.xhtml):

<html xmlns="http://www.w3.org/1999/xhtml"
 xmlns:ui="http://java.sun.com/jsf/facelets"
 xmlns:f="http://java.sun.com/jsf/core">
<f:phaselistener binding="#{urlActionBean.listener}" />

Next is the phase listener and action code:

public class UrlActionBean
{
   /** value of request paramer somevalue=value */
   @NamedEL("param.somevalue")
   private String someValue;
   
   /**
    * Listener activated on render phase calling when not postback.
    */
   public PhaseListener getListener()
   {
      return new PhaseListener() {
         public void beforePhase(PhaseEvent event)
         {
            //only ever call from a 'GET' request (ie not action pressed).
            if (!isPostBack())
               processAction();
         }

         public PhaseId getPhaseId()
         {
            return PhaseId.RENDER_RESPONSE;
         }
      
         public void beforePhase(PhaseEvent event)
         {
         }
      };
   }

   public static boolean isPostBack()
   {
      FacesContext context = FacesContext.getCurrentInstance();
      return context.getRenderKit().getResponseStateManager().isPostback(context);
   }
      
   /**
    * Called after values injected, automatically calls
    */
   public void processAction()
   {
      //only do something if value provided
      if (someValue == null || someValue.length() == 0)
      {
         //ignore
         return;
      }

      String forward = null;
      String viewId = WebUtil.viewId();
      // do action based on viewId. This allows the bean to be used by multiple pages.
      // store result of action
      if ("action".equals(viewId))
         forward = doAction();
         
      //forward to page
      if (forward != null)
      {
         redirect(forward);
         return;
      }
   }
   
   /**
    * Causes the navigation handler to switch pages / send redirect.
    * @param outcome page result mapped in faces-config.xml
    */
   public static void redirect(String outcome)
   {
      FacesContext context = FacesContext.getCurrentInstance();
      context.getApplication().getNavigationHandler().handleNavigation(context, null, outcome);
   }   
}

The listener is a render phase listener, that only calls the action handling when it isn't a postback. The action handling code then checks that the required parameter is supplied and then calls an action based on the viewId. This allows for multiple views to use the same bean, but you could have one bean per url and hence not need this check. The field someValue, gets injected the request parameter named 'somevalue' and since it is injected the bean needs to be request scoped as the injection only occurs when the bean is first created.

In this I use the Guice injection of EL expressions described here, to inject request parameters, however they could be looked up using the ELContext if you can't use this method.

Eclipse Plugins

2009-08-05T21:19:00.012+10:00

After having my elcipse install crashing several times, I thought it a good idea to compile a easily accessible list of plugins I use.

Log4E

Allows loggers to be added to classes, replaces System.out and printStackTrace etc
Website: http://log4e.jayefem.de/content/view/3/2/
Update site: http://log4e.jayefem.de/update

Log4Eclipse

Log4j socket appender host - allows log4j to send log messages directly to eclipse (no need to inspect log files). I have rebuilt it using log4j 1.2.15 see below.
Website: http://www.nitwit.de/log4eclipse/
My build: log4eclipse_0.4.0.jar

Subclipse

Subversion client
Website: http://subclipse.tigris.org/
v1.6 Update site: http://subclipse.tigris.org/update_1.6.x
v1.8 Update site: http://subclipse.tigris.org/update_1.8.x

JBoss Tools

Tools for JBoss server and JSF/Richfaces/Facelets editors. Plus a lot of others (I just use the richfaces plugin).
Website: http://www.jboss.org/tools
Update site: http://download.jboss.org/jbosstools/updates/stable/

TestNG

Plugin to allow execution of testNg (and Junit) tests directly from eclipse.
Website: http://testng.org
Update site: http://beust.com/eclipse

M2Eclipse

Maven integration with eclipse, I mainly use it as a pom file editor.
Website: http://m2eclipse.sonatype.org/
Update site: http://m2eclipse.sonatype.org/sites/m2e

Html Tidy

Based on JTidy, an HTML formatter for eclipse because eclipse's xml/html formatter sucks.
Website: http://eclipsetidy.sourceforge.net/
Download: Zipped update-site

JUtils toString Generator

Website: http://eclipse-jutils.sourceforge.net/
Download: Extract into eclipse directory

FindBugs

A useful static code analysis for finding common coding errors.
Website: http://findbugs.sourceforge.net/
Update site: http://findbugs.cs.umd.edu/eclipse

Multiple Log4J instances in a WebApp

2009-07-30T05:11:00.016+10:00

Many times I've come across the classic problem of different logging instances in an web app server. Most of them involve classloader conflicts:

The webapp has log4j.jar but the webapp has bundled log4j.jar as well and you get errors.
OR you have the log4j.jar in the application server's shared library directory and you have 2 webapps but the configuration conflict - or even just a configuration for the application server itself and one for the webapp.

I've finally come across a solution for log4j. It involves using a repository selector based on a context, this is fully described here - Supporting the log4j RepositorySelector in Servlet Containers.

So the solution to stop conflicts and independently configure each application is this.
First put ALL logging jars in the shared library directory including (log4j.jar, slf4j-api.jar, slf4j-log4j.jar, commons-logging.jar, etc). This ensures that if they one of the libraries is loaded in the main classloader it can access the other jars.
Next is a little extension for log4j: log4j-contrib. Put its jar into the shared library as well.

Next you have to configure each individual app. Add the following to the web.xml (at the top so it is the first called).

<!-- Use log4j.properties from the classpath -->
<context-param>
<param-name>log4jConfigLocations</param-name>
<param-value>logj.properties</param-value>
</context-param>
<listener>
<listener-class>com.mathieucarbou.log4j.web.ContextLoggingListener</listener-class>
</listener>

If you want to have Tomcat use log4j (not just the apps), then add the following configuration:

For catalina.bat add somewhere in the file (line 119):

rem JavaUtilLogging to SLF4J required to be on classpath.
set CLASSPATH=%CLASSPATH%;%CATALINA_HOME%\lib\jul-to-slf4j-1.5.6.jar;%CATALINA_HOME%\lib\slf4j-api-1.5.6.jar;%CATALINA_HOME%\lib\slf4j-log4j12-1.5.6.jar;%CATALINA_HOME%\lib\log4j-1.2.15.jar

Or under linux, catalina.sh add somewhere appropriate (line 163):

# JavaUtilLogging to SLF4J required to be on classpath.
CLASSPATH="$CLASSPATH":"$CATALINA_HOME"/lib/jul-to-slf4j-1.5.6.jar:"$CATALINA_HOME"/lib/slf4j-api-1.5.6.jar:"$CATALINA_HOME"/lib/slf4j-log4j12-1.5.6.jar:"$CATALINA_HOME"/lib/log4j-1.2.15.jar

Additionally if you put the log4j.properties in somewhere other than CATALINA_HOME/lib then you'll need to add that directory to the classpath. e.g.

rem if you put it in /conf
set CLASSPATH=%CLASSPATH%;%CATALINA_HOME%\conf

Now alter conf/logging.properties and replace the entire contents with:

handlers = org.slf4j.bridge.SLF4JBridgeHandler
.handlers = org.slf4j.bridge.SLF4JBridgeHandler

And that's it for the command line.

Running it from Eclipse

Eclipse has a guide how to set it up at Enable JULI logging in Eclipse. To set it up, with the configuration files stored in the workspace under Servers for a server named "Tomcat6-Localhost" add the following to the end of the Server's launch configuration arguments:

-Dlog4j.configuration="log4j.properties"
-Djava.util.logging.config.file="${workspace_loc:Servers/Tomcat6-Localhost-config/logging.properties}"
-Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager

Copy in logging.properties and log4.properties into the workspace configuration directory as per the command line version.

Note: the argument -Dlog4j.configuration, sets the file name to search for on the Tomcat start up classpath. You CANNOT specify the exact file to load, instead you have to add the folder as a class folder (add external folder in eclipse), in order for it to be located.

Under the launch configuration classpath, add the following jars/folders:

jdk:lib/tools.jar
bin/bootstrap.ja
lib/jul-to-slf4j-1.5.6.jar
lib/slf4j-api-1.5.6.jar
lib/slf4j-log4j12-1.5.6.jar
lib/log4j-1.2.15.jar
workspace:Servers/Tomcat6-Localhost-config

Access Control in JSF using a PhaseListener

2009-07-13T02:08:00.007+10:00

After doing a quick search of the web, I did not find any nice solutions to implementing access control in JSF. Using a servlet filter mapping seemed inadequate, and there wasn't any obvious place to start.

I initially tried using a custom NavigationHandler, however that is only used after an action is performed (e.g. #{someBean.action}), and not for directly accessing a URL (e.g. typing in /test.faces). Some more searching revealed that a PhaseListener was the place to do it. After checking the JSF lifecycles I determined that RESTORE_VIEW was the correct place to do it - ALL pages go through at least the RESTORE_VIEW and RENDER_VIEW phases.
You can check the viewId in the afterPhase (as the view has been loaded in this phase, hence can't check in beforePhase) and redirect using the navigation handler as nesecary.

Below is my implementation of it. I used a flexible inclusion/exclusion filter so I can make the rules as complex as I want. This implementation determines the highest level required for each URL and checks the current security level and redirects accordingly.
Alternatively, you could check each level inidividually - starting with LOGGED_IN, checking if the user is logged in and working up.

package devgrok.jsf;

import static devgrok.jsf.AccessControlPhaseListener.AccessLevel.ADMIN;
import static devgrok.jsf.AccessControlPhaseListener.AccessLevel.LOGGED_IN;
import static devgrok.jsf.AccessControlPhaseListener.AccessLevel.NONE;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import javax.faces.event.PhaseEvent;
import javax.faces.event.PhaseId;
import javax.faces.event.PhaseListener;
import javax.servlet.http.HttpSession;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.sun.faces.util.MessageFactory;

import devgrok.jsf.SessionForm;
import devgrok.jsf.UrlFilter;

/**
 * Phase Listener that checks the viewId (URL) against a set of filters to determine the required access level. If the
 * correct level is not there then redirect.
 * 
 * See {@link UrlFilter} for details on the url matching.
 * 
 * @author Chris Watts 2009
 * 
 */
public class AccessControlPhaseListener implements PhaseListener
{
  /** Logger for this class */
  private static final Logger log = LoggerFactory.getLogger(AccessControlPhaseListener.class);

  /** */
  private static final long serialVersionUID = 1L;
  private final static String SESSION_BEAN = "sessionBean";
  private final HashMap<AccessLevel, List<UrlFilter>> levelFilters = new HashMap<AccessLevel, List<UrlFilter>>();

  public enum AccessLevel
  {
    NONE, LOGGED_IN, USER_ACTIVE, ADMIN;
  }

  /**
    * 
    */
  public AccessControlPhaseListener()
  {
    initLevels();
    
    requires(LOGGED_IN)
      .include("*")
      .exclude("/index.xhtml")
      .exclude("/login.xhtml")
      .exclude("/user/newUser.xhtml");

    requires(USER_ACTIVE)
      .include("/user/*")
      .exclude("/user/newUser.xhtml");

    requires(ADMIN)
      .include("/admin/*");
  }

  private void initLevels()
  {
    AccessLevel[] levels = AccessLevel.values();
    for (int i = 1; i < levels.length; i++)
    {
      levelFilters.put(levels[i], new ArrayList<UrlFilter>());
    }
  }

  private UrlFilter requires(AccessLevel level)
  {
    //ALL is default
    if (level == NONE)
      return null;

    UrlFilter filter = new UrlFilter();
    List<UrlFilter> list = levelFilters.get(level);
    list.add(filter);
    return filter;
  }

  /*
   * (non-Javadoc)
   * 
   * @see javax.faces.event.PhaseListener#afterPhase(javax.faces.event.PhaseEvent)
   */
  public void afterPhase(PhaseEvent event)
  {
    try
    {
      //check have correct access
      FacesContext context = event.getFacesContext();
      HttpSession session = (HttpSession) context.getExternalContext().getSession(true);
      SessionForm sessionBean = (SessionForm) session.getAttribute(SESSION_BEAN);
      if (sessionBean == null)
      {
        log.error("Could not obtain instance of sessionBean");
        return;
      }

      //can't use this here. only valid at render response phase?
      String viewId = context.getViewRoot().getViewId();
      AccessLevel required = requiredLevel(viewId);
      log.debug("Required level={} for viewId={}", required, viewId);

      //check if page require access:
      switch (required) {
      case NONE:
        break;
      case LOGGED_IN:
        if (!sessionBean.isLoggedIn())
          redirectLogin(event.getFacesContext(), sessionBean);
        break;
      case USER_ACTIVE:
        if (!sessionBean.isActive())
          redirectActive(event.getFacesContext());
        break;
      case ADMIN:
        if (!sessionBean.isAdmin())
          redirectAdmin(event.getFacesContext());
        break;
      default:
        //error
        log.error("huh?");
        throw new IllegalArgumentException("Not a valid access level");
      }
    }
    catch (Exception e)
    {
      // TODO Auto-generated catch block
      log.error("beforePhase caught exception", e);
    }

  }

  /*
   * (non-Javadoc)
   * 
   * @see javax.faces.event.PhaseListener#beforePhase(javax.faces.event.PhaseEvent)
   */
  public void beforePhase(PhaseEvent event)
  {

  }

  private void redirectLogin(FacesContext context, SessionForm sessionForm)
  {
    //trigger login popup to be shown on render.
    sessionForm.logIn();
    addError(context, "access.loginrequired");
    context.getApplication().getNavigationHandler().handleNavigation(context, null, "index");
  }

  private void redirectActive(FacesContext context)
  {
    addError(context, "access.activerequired");
    context.getApplication().getNavigationHandler().handleNavigation(context, null, "userActivate");
  }

  private void redirectAdmin(FacesContext context)
  {
    addError(context, "access.adminrequired");
    context.getApplication().getNavigationHandler().handleNavigation(context, null, "home");
  }

  /**
   * Add keyed error/message.
   * 
   * @param level
   * @param key
   *           message key
   */
  private void addError(FacesContext context, String key)
  {
    FacesMessage fMessage = MessageFactory.getMessage(key);
    if (fMessage != null)
    {
      FacesContext facesContext = FacesContext.getCurrentInstance();
      fMessage.setSeverity(FacesMessage.SEVERITY_ERROR);
      facesContext.addMessage(null, fMessage);
    }
  }

  /**
   * Checks defined filters for view id, checks starting at the highest level down to NONE.
   * 
   * @return the matching level or {@link AccessLevel#NONE} if none matching.
   */
  private AccessLevel requiredLevel(String viewId)
  {
    AccessLevel[] levels = AccessLevel.values();
    for (int i = levels.length - 1; i > 0; i--)
    {
      if (checkLevel(levels[i], viewId))
        return levels[i];
    }

    return AccessLevel.NONE;
  }

  private boolean checkLevel(AccessLevel level, String viewId)
  {
    return matchUri(levelFilters.get(level), viewId);
  }

  private boolean matchUri(List<UrlFilter> list, String uri)
  {
    for (UrlFilter filter : list)
    {
      if (filter.matches(uri))
        return true;
    }
    return false;
  }

  /*
   * (non-Javadoc)
   * 
   * @see javax.faces.event.PhaseListener#getPhaseId()
   */
  public PhaseId getPhaseId()
  {
    //ALL access go through RESTORE_VIEW and RENDER_VIEW (even direct url)
    return PhaseId.RESTORE_VIEW;
  }

}

package devgrok.jsf;

import java.util.ArrayList;
import java.util.regex.Pattern;

/**
 * An inclusion/exclusion filterset, similar to ant's fileset but does not support directories in the same style(**,
 * etc).
 * 
 * For example:
 * <ul>
 * <li>/servlet/* matches all urls starting with "/servlet/" e.g. /servlet/this.html
 * <li>*.do matches all urls that end in ".do" - e.g. mypage.do
 * <li>/servlet/*.do matches all urls starting with "/servlet/" and end in ".do"  - e.g. /servlet/mypage.do
 * </ul>
 * 
 * @author Chris Watts 2009
 * 
 */
public class UrlFilter
{
  private ArrayList<Pattern> include = new ArrayList<Pattern>();
  private ArrayList<Pattern> exclude = new ArrayList<Pattern>();

  public UrlFilter()
  {

  }

  /**
   * Include the wildcard(*) built pattern.
   * 
   * @param pattern
   * @return
   */
  public UrlFilter include(String pattern)
  {
    include.add(generateExpression(pattern));
    return this;
  }

  /**
   * Exclude the wildcard(*) built pattern.
   * 
   * @param pattern
   * @return
   */
  public UrlFilter exclude(String pattern)
  {
    exclude.add(generateExpression(pattern));
    return this;
  }

  /**
   * Checks to see if uri matches at least ONE inclusion filter and doesn't match ANY exclusion filters.
   * 
   * @param uri
   * @return
   */
  public boolean matches(String uri)
  {
    boolean match = false;

    //check inclusions
    for (Pattern pattern : include)
    {
      match = match || pattern.matcher(uri).matches();
    }

    if (!match)
      return false;

    //check exclusions
    for (Pattern pattern : exclude)
    {
      match = match && !pattern.matcher(uri).matches();
    }
    return match;
  }
  
  /** regular expression special character */
  private static char[] specialChars = { '[', '\\', '^', '$', '.', '|', '?', '*', '+', '(', ')' };

  /**
   * 
   * @param input
   * @return
   */
  private static Pattern generateExpression(String input)
  {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < input.length(); i++)
    {
      char letter = input.charAt(i);
      if (letter == '*')
      {
        sb.append(".*");
      }
      else if (contains(specialChars, letter))
      {
        sb.append("\\" + letter);
      }
      else
      {
        sb.append(letter);
      }
    }
    return Pattern.compile(sb.toString());
  }

  private static boolean contains(char[] array, char value)
  {
    if (array == null || array.length == 0)
    {
      return false;
    }

    for (int i = 0; i < array.length; i++)
    {
      char o = array[i];
      if (o == value)
      {
        return true;
      }
    }

    return false;
  }
}

Update 2010/10/21: Here is a zip of the source

JSF - Injecting Managed Beans into Managed Beans

2009-07-13T01:12:00.008+10:00

Using Google Guice and JSF with something like GuiceSF to inject the JSF managed beans (backing beans) gives you a lot of power over the injection. However, by doing so JSF no longer resolves the EL expressions from faces-config.xml and injects them into the managed beans. An easy way around this, and somewhat cleaner, is to create an annotation that is 'bound' to an EL expression. To do so requires the use of GuiceyFruit's extensions to Guice.

First create the annotation:

import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

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

import com.google.inject.BindingAnnotation;

/** 
 * Injection by expression language.
 * @see com.google.inject.name.Named
 */
@BindingAnnotation
@Target( { FIELD, PARAMETER, METHOD })
@Retention(RUNTIME)
public @interface NamedEL
{
   /** expression language (without the #{}). */
   String value();
}

Next you configure the annotation and the provider inside your module:

public final class GuiceModule extends GuiceyFruitModule
{
   @Override
   protected void configure()
   {
      bindAnnotationInjector(NamedEL.class, ELProvider.class);
   }
}

And finally the provider:

public class ELProvider extends AnnotationMemberProviderSupport<NamedEL>
{
   /** Logger for this class */
   private static final Logger log = LoggerFactory.getLogger(ELProvider.class);

   private Injector injector;
   private FacesContext context;

   @Inject
   public ELProvider(Injector injector)
   {
      this.injector = injector;
   }

   public FacesContext getContext()
   {
      return context;
   }

   @Inject(optional = true)
   public void setContext(FacesContext context)
   {
      this.context = context;
   }

   public boolean isNullParameterAllowed(NamedEL annotation, Method method, Class<?> parameterType, int parameterIndex)
   {
      return false;
   }

   protected Object provide(NamedEL resource, Member member, TypeLiteral<?> requiredType, Class<?> memberType, Annotation[] annotations)
   {
      String name = getName(resource, member);

      Binding<?> binding = Injectors.getBinding(injector, Key.get(requiredType, Names.named(name)));
      if (binding != null)
      {
         return binding.getProvider().get();
      }

      try
      {
         if (context == null)
         {
            context = FacesContext.getCurrentInstance();
         }
         return getBean(name, requiredType.getRawType());
      }
      catch (ProvisionException e)
      {
         throw e;
      }
      catch (Exception e)
      {
         throw new ProvisionException("Failed to find name '" + name + "' ExpressionResolver. Cause: " + e, e);
      }
   }

   String getName(NamedEL resource, Member member)
   {
      String answer = resource.value();
      if (answer == null || answer.length() == 0)
      {
         answer = member.getName();
      }
      if (answer == null || answer.length() == 0)
      {
         throw new IllegalArgumentException("No name defined");
      }
      return answer;
   }
   
   private <T> T getBean(String expr, Class<T> expected)
   {
      try
      {
         Application app = context.getApplication();
         ValueExpression ve = app.getExpressionFactory().createValueExpression(context.getELContext(), "#{" + expr + "}", expected);
         return (T) ve.getValue(context.getELContext());
      }
      catch (RuntimeException e)
      {
         log.error("getBean caught RuntimeException", e);
         throw e;
      }
   }
}

It uses a custom FacesContext provider bound to ServletScopes.REQUEST but because its optional it defaults to looking it up the standard JSF way. This allows startup time initialisation of singletons, which occurs outside the request scope.

Usage

To use it is pretty simple. Say you had a bean called mybean, then the following would inject it during the normal creation time (e.g. when first referencing a session scoped bean).

/** managed bean 'mybean' */
@NamedEL("mybean")
private String mybean;

/** request parameter 'key' */
@NamedEL("param.key")
private String paramKey;

The second reference is a nifty trick which injects the value of the request parameter 'key'.

Resources

Guicesf seems to be down so here are my copies of them (slightly modified). binary source
Source for this example: download source

EJB3 Stateful Session Beans with ejbCreate

2009-07-08T00:22:00.008+10:00

I had trouble obtaining a stateful session bean using the EJB3 pattern when trying to pass initial data to it. You can use injection to create instances of stateful beans by simply declaring an instance variable in a bean, for example: @EJB MyStatefulLocal mylocal;. But this doesn't allow you to pass any data on creation. The answer is to use a EJBLocalHome interface like in EJB2 but it's a bit complicated with all the annotations. The ejbCreate method from EJB2.1 is called create in the local home interface and called whatever you want in the bean itself (as long as it is annotated with @Init Below is an example. You can download the source here: download source.

/** Local Interface. Dummy interface to enable us to return the Business interface. */
public interface MyStatefulLocalEjb2 extends EJBLocalObject, MyStatefulLocal 
{}

/** Local Business Interface. Put business method definitions here */
public interface MyStatefulLocal
{}

/** Define method(s) which create the EJB. Must be of name create([optional parameters]),  can be anything e.g. createMyBean(). */
public interface MyStatefulLocalHome extends EJBLocalHome
{
   public MyStatefulLocalEjb2 create(MyEntity initialData);
}

/** This is the EJB itself, note that it implements the "Local Business Interface" not the "Local Interface". */
@Stateful
@LocalHome(MyStatefulLocalHome.class)
public class MyStatefulBean implements MyStatefulLocal
{
   /** matches method in {@link MyStatefulLocalHome#create(MyEntity)} */
   @Init
   public void init(MyEntity initialData)
   {
   }
}

/** This shows using it from another session bean or message bean. */
public class SomeBean
{
   @EJB
   private MyStatefulLocalHome home;

   public void obtainStateful()
   {
      MyEntity initialData = new MyEntity();
      MyStatefulLocal myStateful = home.create(initialData);
   }
}

Reacquiring a Stateful Session Bean on NoSuchEJBException

2009-07-02T00:33:00.005+10:00

In the current project I'm working on I'm using a Tomcat server connecting to a remote JBoss instance. We're using a Stateful Session Bean (SFSB) to hold the session information for the current user for authentication/access control purposes. The bean is stored in tomcat within the session (within a session-scoped managed bean actually) and generally it works fine.
However, if the bean is destroyed on the server then, as per the EJB specification, an NoSuchEJBException is thrown. This could be handled individually by catching the exception, printing a user friendly message and getting a new instance of the session bean. However, it you've got several method calls across multiple classes, having this try/catch code throughout all the classes bloats the code and just plain looks ugly.

I wanted a solution where I didn't need to touch the module variable that stored the EJB given to me by jboss - I wanted it to obtain a new instance itself. The reason being, if I have this instance shared across multiple JSF managed beans (some stored in session-scope, some in request), the other classes shouldn't have to know that a new instance of the EJB was obtained.

The solution is to use a nifty feature of Java reflection API - a Proxy that passes calls to a InvocationHandler instance that you write. Actually the EJB instance JBoss's context factory provides you is a Proxy (and the same is true for other app servers), which makes wrapping it even easier. Observe:
First create a class that implements InvocationHandler and a custom interface we'll use to directly access the handler called StatefulProxy:

package devgrok.proxy;

import java.io.Serializable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import javax.ejb.NoSuchEJBException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
* Utility wrapper, automatically obtains a new instance of the session bean when the existing instance is lost. Uses
* jndi to obtain new instance.
* @author Chris Watts 2009
*/
public class JndiRemoteProxyInvocationHandler implements InvocationHandler, StatefulProxy, Serializable
{
/** Logger for this class */
private static final Logger log = LoggerFactory.getLogger(JndiRemoteProxyInvocationHandler.class);

private Proxy remoteBean = null;
private final String jndiName;

/*
* (non-Javadoc)
* 
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
if (method.getDeclaringClass().equals(StatefulProxy.class))
return method.invoke(this, args);

if (remoteBean == null)
getNewInstance();

try
{
//relay it on to JBoss's handler
InvocationHandler handler = Proxy.getInvocationHandler(remoteBean);
return handler.invoke(remoteBean, method, args);
}
catch (NoSuchEJBException e)
{
log.warn("caught exception {}", e.toString());
remoteBean = null;
throw e;
}
}

/**
* Constructs the proxy, obtaining the instance from the given jndi name.
* @param jndiName
*/
public JndiRemoteProxyInvocationHandler(String jndiName)
{
this.jndiName = jndiName;
getNewInstance();
}

/**
* Obtains a new instance of the bean from the context.
* @return
*/
public void getNewInstance()
{
try
{
Context context = new InitialContext();
this.remoteBean = (Proxy) context.lookup("java:/comp/env/" + jndiName);
}
catch (NamingException e)
{
log.warn("caught exception {}", e.toString());
throw new RuntimeException(e);
}
}

public Object getRemoteBean()
{
return remoteBean;
}

public void clearInstance()
{
remoteBean = null;
}
}

Next the interface to provide access to the utility methods:

package devgrok.proxy;

/**
* Interface to allow calls to the InvocationHandler for the stateful bean proxy.
* @author Chris Watts 2009
*/
public interface StatefulProxy<T>
{
/**
* Get a new instance of the underlying class.
*/
public void getNewInstance();

/**
* Returns the remote bean.
* 
* @return
*/
public T getRemoteBean();

/**
* Clears the stored instance of the bean (useful for logout/cleanup).
*/
public void clearInstance();
}

Now all that is left is obtaining an instance. Since I'm using Google Guice I wrote a provider (aka a factory) but you could easily adapt it:

package devgrok.proxy;

import java.lang.reflect.Proxy;

import com.google.inject.Provider;

/**
* A guice provider, providing a proxied EJB looked up by JNDI.
* @author Chris Watts 2009
*/
public class ProxyProvider<T> implements Provider<T>
{
private final String jndiName;
private final Class<T> clazz;

/**
* @param jndiName
* @param clazz
*/
public ProxyProvider(String jndiName, Class<T> clazz)
{
this.jndiName = jndiName;
this.clazz = clazz;
}

/*
* (non-Javadoc)
* 
* @see com.google.inject.Provider#get()
*/
public T get()
{
return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[] { clazz, StatefulProxy.class },
new JndiRemoteProxyInvocationHandler(jndiName));
}

}

To bind it:

bind(MySessionRemote.class).toProvider(new ProxyProvider<MySessionRemote>("ejb/myEjb", MySessionRemote.class)).in(ServletScopes.SESSION);

Tomcat - load & bind an external naming context

2009-06-21T20:00:00.003+10:00

In my previous post Injecting JBoss EJB3 beans into Tomcat6, I used Tomcat's ability to bind EJB's to the local JNDI context by specifying JBoss' NamingContextFactory and the URL to the EJB. However in the process of using it, I discovered a problem with Stateful Session Beans.

I was getting NoSuchEJBException - either after a redeploy to JBoss, or calling the @Remove annotated method on the session bean. A lot of debugging later, I discovered that the cause was that Tomcat was initially storing a ejb ref (org.apache.EjbRef) in the context and when first accessed it looks up the EJB using the factory and then replaces the reference in the context with the instance of the EJB. Every subsequent lookup in the context returns the same instance.

This however breaks the JEE5 contract:

FROM JSR 220: NOTE: When a stateful session bean is looked up or otherwise
obtained through the explicit JNDI lookup mechanisms, the container must
provide a new stateful session bean instance, as required by the Java EE
specification (Section “Java Naming and Directory Interface (JNDI) Naming
Context” [12]).

I initially tried a few hacks to stop Tomcat 6 storing the instance and only keeping the ref, but I was worried about the lag every I required a new instance. Each time it creates a context factory, EJB factory etc to look up the EJB. If you were manually doing the lookup using a custom service locator, you would create a singleton service locator and stores a initial context with the remote app server's details pumped in. Thus everytime you wanted an instance a single call to the existing context would be all that was required.

My solution I felt was to bind an external context naming tree to the local naming tree. That way you could reference any external object easily on the external context with just a @EJB ref. The resulting patch is located here, it is against Tomcat 6.0.20. You can also download my precompiled binary:
catalina.jar
And the source:
apache-tomcat-6.0.20-src

To use it create a context.xml:

<Context>
   <!-- Binds the remote context tree starting at myear to local name java:/comp/env/ejb. -->
   <Resource name="ejb" type="javax.naming.Context" factory="org.jnp.interfaces.NamingContextFactory" URL="jnp://apphost:1099/myear"/>
</Context>

Next if you want to reference a bean which has a @Stateful(mappedName="myear/myBean"), using the following in your JSF/contains managed bean:

public class TomcatManagedBean
{
   @EJB(name="ejb/myBean")
   private MyBeanRemote session;

Injecting JBoss EJB3 beans into Tomcat6

2009-06-18T20:43:00.008+10:00

Injecting EJB's into a managed bean (a bean spawned by appserver, of a JSF managed bean) inside an application server is simple:

public class AppManagedBean
{
   @EJB(mappedName="ejb/myBean")
   private MyBeanRemote session;

The container looks up the mapped bean and injects it. Easy.

However in tomcat it gets a little messy. Tomcat doesn't document how to inject them. It assumes something annotated with @EJB is in the context somewhere and tries to look it up.
It has documented how to lookup ejb's by defining entries in your context.xml or server.xml. But there isn't anything documented for defining EJB's. Looking at the soure it has support for <Ejb/> references but no real clue on how to configure it. So after stepping through the code I came up with the following soloution:

My environment is JBoss 5 running remotely (on localhost). A seperate instance of Tomcat 6. In it I have defined a session bean:

@Stateful(mappedName="userSession")
public class UserSessionBean implements UserSessionRemote

This bean is used by a JSF backing bean (i.e. a managed bean):

public class TomcatManagedBean
{
   @EJB(name="ejb/myBean")
   private MyBeanRemote session;

In order for this bean to bound to the context, you need to configure Tomcat. There are 2 ways: in the server.xml or in the context.xml
I find that putting it in META-INF/context.xml is the easiest, as it gets reloaded nicely in Eclipse. The name="ejb/myBean" corresponds to the name attribute in the <Ejb/> below. In the URL is the appserver name, port, then the mapped name (it could be myProject/ejb/bean or whatever you feel like) - as long as it matched the mappedName on the EJB.

<Context>
   <!-- Makes Tomcat manage the ejb for you. -->
   <Ejb name="ejb/myBean" type="Session" factory="org.jnp.interfaces.NamingContextFactory" URL="jnp://localhost:1099/userSession" />
</Context>

Update 2010/02/02: Correct the mappedName in AppManagedBean

Change user name in eclipse

2009-06-14T02:01:00.002+10:00

The code comment templates are handy for inserting the author of a class, which is handy in rather large projects. For example, here is my template for types(classes):

/**
 * @author ${user}
 *
 * ${tags}
 */

However under windows (and probably *nix as well) it just inserts the current user name. But I want it always to display my real name - which is more meaningful when employees come and go.

You can change it by passing this argument on the comment line:
You need to put it at the end of your command line.
eclipse.exe -vmargs -Duser.name="You real name"

A few good Guice Tutorials

2009-06-12T21:06:00.005+10:00

I came across these rather good Guice tutorials in trying to find a way to integrate Google Guice in an application server (EJB3).

Part 1: a quick intro.
Part 2: method interceptors.

This was the tricky one, how to inject EJB's which are created by the container without having to have every class extend a base class with a @PostConstruct annotated method to do the injecting. The solution was to use the new interceptors introduced into JEE 5.
Part 3 – Integrating Guice with EJB
If you want a little background, see EJB Interceptors.

CommandButton not calling action when using immediate and rendered

2009-06-06T22:53:00.015+10:00

I came across a problem with using a custom command component, that when using immediate it wasn't calling the action I had bound to it. I started resolving the issue and discovered my decode code wasn't being called. I had create a custom button, cannibalising and extending the original CommandButton component. Due to my lack of understanding of setting up renderkits, I gave up and hacked in a renderer:

public class ImageButton extends HtmlCommandButton
{
   private ImageButtonRenderer render = new ImageButtonRenderer();
   
   @Override
   public void decode(FacesContext context)
   {
      render.decode(context, this);
   }
   
   @Override
   public void encodeBegin(FacesContext context) throws IOException
   {
      render.encodeBegin(context, this);
   }

This resulted in decode not always working. I came across this nice summary of how to write a custom component and altered my code accordingly. Decode worked but the action was still not called. Thought the cause was just with immediate="true". So I swtiched to using a standard commandButton for testing.

<h:inputhidden value="#{testBean.add}" immediate="true" />
<h:commandbutton value="Delete" immediate="true" rendered="#{!testBean.add}" />

However the command button was still not being decoded, as I thought immediate on the attribute should work but for the 2nd time I've misunderstood how it works for input components. Immediate on input components only changes priority of validation, it doesn't cause them to update the model any earlier.

UIComponentBase.processDecodes:1018 calls isRendered() - which returns false as the Update Model Values phase hasn't been applied. Which skips the decode of the the component. Which clearly isn't right. Whether it was rendered or not should be remembered from the Render phase during the decode(Apply Request Values) phase. In the following phases it should be calculated from the EL binding. This to me seems a bug in the specification or the implementation.

So how to use a model value for the rendered attribute for a button with immediate on?

The answer use Tomahawk's saveState tag. The state is maintained on the server side, and as long as it is put before the other tags that need it, it will restore the model/attribute to the same value it was after the Render phase during the Apply Request Values phase. Thus when it goes to decode the button, the same values that were used to calculate the rendered during the previous rendering to create this page are used.

<t:savestate value="#{testBean.add}" />
<h:commandbutton value="Delete" immediate="true" rendered="#{!testBean.add}" />

ClassCastException with PortableRemoteObject.narrow() EJB2/EJB3

2009-06-06T02:57:00.006+10:00

After switching to JBoss 5 and recreating my EAR project inside eclipse, I started getting ClassCastException:

java.lang.ClassCastException
  at com.sun.corba.se.impl.javax.rmi.PortableRemoteObject.narrow(PortableRemoteObject.java:229)
  at javax.rmi.PortableRemoteObject.narrow(PortableRemoteObject.java:137)

Object obj = initialContext.lookup(ejbReferenceComponent);
MyEJBRemoteHome home = javax.rmi.PortableRemoteObject.narrow(obj, MyEJBRemoteHome.class);

After looking around, the cause of it is how the app server determines whether to give you a EJBHome instance which you have to use .narrow() then .create() to get a reference to the bean for EJB2 vs returning a proxy to the bean itself for EJB3. JBoss has some information on referencing EJB3 from EJB2 environments and vice-versa.

The summary generally is if the application.xml has the EJB2 header then it gives you an EJBHome interface.
If the ear's ejb-jar has the EJB3 header then it gives you a proxy to the bean itself (no need for narrow/create).

The lack of a more intelligent error from PortableRemoteObject is a bit annoying. However here is a generic solution for cases when your switching between environments:

public <T, S extends EJBHome> T lookupEJB(String ejbReferenceComponent, Class<S> homeClass, Class<T> ejbClass)
   throws NamingException, IllegalArgumentException, SecurityException, IllegalAccessException, InvocationTargetException,
   NoSuchMethodException
{
  log.debug("{}", initialContext.getEnvironment());
  java.lang.Object remote = initialContext.lookup(ejbReferenceComponent);

  if (ejbClass.isInstance(remote))
    return (T) remote;

  S home = (S) PortableRemoteObject.narrow(remote, homeClass);

  return (T) home.getClass().getMethod("create", (Class[]) null).invoke(home, (Object[]) null);
}

Of course the simplest approach is to convert it all to EJB3 and you won't have to worry :)

Simple transactional unit testing database

2009-03-24T08:44:00.004+11:00

Last week I wrote a post about using Google Guice to perform transaction handling using interceptors.
When it came time to write some database level unit tests, I wanted to have the same kind of simple transaction handling so that every unit test is rolled back on completion. Rolling back the changes each test makes is necessary for the tests to be repeatable and consistent.

TestNG provides convenient way to do processing before and after each method is called using @BeforeMethod and @AfterMethod. All you need to do is annotate methods that you want automatically rolled back with @Transactional then check for it and act accordingly. The same could be done with JUnit using a RunListener.

Below is my implementation. I use just one connection per unit test, it can easily be adapted across multiple connections.

public abstract class BaseUtilTest
{
  private static final Logger log = Logger.getLogger(BaseUtilTest.class);
  protected Connection con;

  @BeforeClass
  public void init()
  {
    Injector myInjector = Guice.createInjector(new TestModule());
    myInjector.injectMembers(this);
  }

  @BeforeMethod
  public void before(Method method) throws Exception
  {
    con = ConnectionUtils.getConnection();
    if (method.isAnnotationPresent(Transactional.class))
    {
      //do transactional
    }
  }

  @AfterMethod
  public void after(Method method, ITestContext context) throws Exception
  {
    if (method.isAnnotationPresent(Transactional.class))
    {
      //rollback any changes
      rollback();
    }

    ITestResult result = Reporter.getCurrentTestResult();
    if (!result.isSuccess() && result.getThrowable() != null)
    {
      log.error(method.toGenericString(), result.getThrowable());
    }
  }
  
  void rollback()
  {
    if (con == null)
    {
      log.warn("No bound connection to rollback");
      return;
    }
    log.info("Rolling back transaction");
    try
    {
      con.rollback();
    }
    catch (SQLException e)
    {
      log.warn(e);
    }
  }  
}

Lightweight transaction handling in Tomcat

2009-03-20T13:19:00.011+11:00

With Enterprise Java Beans (EJB) used with Container-Managed Transactions (CMT), transactions are transparently handled by the application server. When a method is marked with @TransactionAttribute(REQUIRED) then it starts a transaction (if one is not already started) and on competition of the method commits it (if it created the transaction). If an exception occurs, then the container rolls back the transaction. The beauty of it, is that it requires no extra code, just a single annotation.

However, if running outside an application server, e.g. in a Tomcat only environment, then container managed transactions cannot be used. The common approach would be to use Spring.
Spring provides the same functionality as EJB's but with a few drawbacks. It requires a large number of libraries to be included in your classpath plus a cumbersome to maintain configuration file just to set up some basic transaction handling. Spring does have its advantages but is overkill in a lot of cases.

Enter Google Guice. Google's dependancy injection 'framework'.

Guice and be configured as simply or as complex as you want.
In the most simple case, guice requires very little configuration. Unless specified, all beans have no scope. That is, they are single use - new instances are created for each injection. POJO services that don't implement an interface don't even need to be named. If you so chose, you could create an empty configuration Module and let everything auto-wire.

Onto transaction handling.
Guice 1 doesn't provide any mechanism to perform transaction handling. However it turns out that doesn't matter as it takes very little effort to implement a simple transaction handler.
The trick is to define an annotation, then bind an interceptor to all methods that are annotated. The interception is done at load time, so all the complex matching is done once with Guice's internal CGLib proxies created.

First create the annotation to use (you could use JEE ones if you wanted but would need to put them in the class path).

@Retention(RetentionPolicy.RUNTIME)
@Target( { ElementType.METHOD, ElementType.TYPE })
public @interface Transactional
{
}

Next define your Module. Modules are Guice's configuration.

import static com.google.inject.matcher.Matchers.annotatedWith;
import static com.google.inject.matcher.Matchers.subclassesOf;

import org.owatta.service.AbstractService;
import org.owatta.annotation.Transactional;

import com.google.inject.AbstractModule;

public class ServiceModule extends AbstractModule
   {
   @Override
   protected void configure()
   {
      //this line tells guice to bind TransactionInterceptor to any class
      //that is a subclass of AbstractService and is annotated with @Transactional
      //the subclassesOf() could be replaced with Matchers.any()
      bindInterceptor(subclassesOf(AbstractService.class), annotatedWith(Transactional.class), new TransactionInterceptor());
   }
}

Next create your interceptor. Since I only need to handle transaction directly on a connection my transaction interceptor requires little work.

/**
*
*/
package org.owatta.modules;

import java.sql.Connection;
import java.sql.SQLException;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.log4j.Logger;
import org.owatta.web.FacesFilter;

/**
* Simple transaction interceptor. Commits on success, rolls back on error.
* @author Chris Watts
*/
public class TransactionInterceptor implements MethodInterceptor
{
   private final static Logger log = Logger.getLogger(TransactionInterceptor.class);

   public Object invoke(MethodInvocation arg0) throws Throwable
   {
      Object returnValue = null;
      try
      {
         returnValue = arg0.proceed();
         Connection con = FacesFilter.getConnection();
         if (con == null)
         {
            log.warn("No bound connection to rollback");
         }
         else
         {
            try
            {
               con.commit();
            }
            catch (SQLException e)
            {
               log.error("Error commiting transaction, rolling back", e);
               //make sure the caller knows the commit failed
               throw new RuntimeException(e);
            }
         }
         return returnValue;
      }
      catch (Throwable t)
      {
         rollback();
         throw t;
      }
   }

   /**
    * perform rollback
    */
   void rollback()
   {
      Connection con = FacesFilter.getConnection();
      if (con == null)
      {
         log.warn("No bound connection to rollback");
         return;
      }
      log.info("Rolling back transaction");
      try
      {
         con.rollback();
      }
      catch (SQLException e)
      {
         log.warn(e);
      }
   }
}

Since I'm using JSF, I'm using GuiceSF as a variable resolver in order to inject the managed beans. I put the following in my web.xml:

<!-- guice / jsf -->
<context-param>
   <param-name>com.guicesf.Modules</param-name>
   <param-value>com.google.inject.servlet.ServletModule,org.owatta.modules.ServiceModule</param-value>
</context-param>

<!-- Entity Manager Filter declaration -->
<filter>
   <filter-name>GuiceFilter</filter-name>
   <filter-class>com.google.inject.servlet.GuiceFilter</filter-class>
</filter>

<filter-mapping>
   <filter-name>GuiceFilter</filter-name>
   <url-pattern>*.faces</url-pattern>
</filter-mapping>

This is actually 2 parts. The first part configures GuiceSF, the 2nd configures Guice so it can use request / session scoped beans. Depending on your needs this may not be necessary.
The final JSF step is to configure the variable resolver, add the following to faces-config.xml:

<application>
<!-- injector for managed beans -->
<el-resolver>com.guicesf.GuiceResolver</el-resolver>
</application>

The final step is to put the required jars on the class path:

guice-1.0.jar
aopalliance.jar
guice-servlet-1.0.jar (only required if you want servlet scope handling)
guicesf-0.1.jar (for JSF integration)

The elegance of this solution is that it is VERY lightweight, very little lock-in and complete control.

Logging Tomcat 6 startup via log4j

2009-01-31T07:07:00.008+11:00

For a recent task I had the need to log the tomcat startup process via log4j (so I could view it in eclipse using the log4eclipse plugin).
The simple copying log4j.properties and log4j.jar into TOMCAT/lib didn't work as it had for previous versions.
After some quick digging around I finally read the right section of the documentation. The steps are pretty easy to follow.

The jar of juli (their logger) that comes with the standard build doesn't allow for commons-logging.
To get it to work you need to download the source and compile the extras commons-logging.
Which is a simple:

ant download
ant build-only
ant -f extras.xml commons-logging

Replace $CATALINA_HOME/bin/tomcat-juli.jar with output/extras/tomcat-juli.jar.
Place output/extras/tomcat-juli-adapters.jar in $CATALINA_HOME/lib.

For apache-tomcat-6.0.14-src you'll need to change build.properties.default line 45:

jdt.loc=http://archive.eclipse.org/eclipse/downloads/drops/R-3.2.2-200702121330/eclipse-JDT-3.2.2.zip

Additionally as of apache-tomcat-6.0.18-src, there are errors compiling the target build-tomcat-dbcp using JDK 1.6; so use JDK 1.5 to do the 'ant download' step (or all).

Integration testing Spring MVC without web server

2008-12-09T08:36:00.002+11:00

Unit testing is very useful for finding bugs in isolated pieces of code and for checking whether a method obeys its contract. However, testing the configuration of an app or testing how a framework like Spring MVC calls or manipulates the data passed in.

This is where integration testing comes in. Testing the app with everything wired in. End to end testing. This usually entails a tester firing up the browser and working through a list of test cases. This can be automated with something similar Test Director or made into JUnit test cases using HtmlUnit or HttpUnit.

Creating a test case using HtmlUnit (or HttpUnit if you want to do more work) can be quiet tedious and time consuming. However there is a way to programmatically invoke the Spring's servlet and obtain the response object without having to parse html. By invoking it directly you gain a level of control, and the testing can be more specific. The downside is that you don't test the JSP files, though I'm sure there are ways to do that too.

When it came to actually setting up the environment to perform the test, I discovered this was the one area where Spring's test framework is lacking. So I ended up extending the framework to perform the necessary tasks.

Loading The Web Application Context
The first hurdle encountered was trying to load the correct application context.
The test framework, by default loads the GenericXmlContextLoader. However the DispatcherServlet expects to a XmlWebApplicationContext to be loaded. No problem, the annotation @ContextConfiguration allows a custom loader to be specified.


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:/common-beans.xml", "classpath:/myservlet-test.xml" }, loader = WebAppLoader.class)

Just extend AbstractContextLoader, override loadContext(), create an instance of XmlWebApplicationContext create a MockServletContext set the ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE to be the new context. Next obtain a reference to the servlet that was defined in the myservlet-test.xml


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

<!-- ========================= SERVLET ========================= -->
<bean id="aptt" class="org.springframework.web.servlet.DispatcherServlet">
</bean>
</beans>

As long as you set the servlet context's path to be the web directory of the project your testing then all the relevant configuration files will be loaded.
Here is the loader:


/**
* @author Chris Watts
*
*/
public class WebAppLoader extends AbstractContextLoader
{
   /** Application root directory (usually project/web). */
   protected String basePath = "../myproj/web";
   /**
    * set to false for each servlet to load an additional context (the way
    * {@link DispatcherServlet} works by default). Useful if you want to load
    * the servlet's context in the main context.
    */
   protected boolean shareContext = false;
   private static final Logger logger = Logger.getLogger(WebAppLoader.class);
   /** attribute name to pass context via */
   private static final String CONTEXT_PATH = "com.example.WebApplicationContext";

   /**
    * {@inheritDoc}
    *
    * @see org.springframework.test.context.support.AbstractContextLoader#getResourceSuffix()
    */
   @Override
   protected String getResourceSuffix()
   {
       return "-context.xml";
   }

   /**
    * {@inheritDoc}
    *
    * @see org.springframework.test.context.ContextLoader#loadContext(java.lang.String[])
    */
   @SuppressWarnings("unchecked")
   public XmlWebApplicationContext loadContext(String... locations) throws Exception
   {
       if (logger.isDebugEnabled())
       {
           logger.debug("Loading ApplicationContext for locations ["
                   + StringUtils.arrayToCommaDelimitedString(locations) + "].");
       }

       //resolve absolute path
       File path = ResourceUtils.getFile(basePath);
       if (!path.exists())
           throw new FileNotFoundException("base path does not exist; " + basePath);
       basePath = "file:" + path.getAbsolutePath();
      
       XmlWebApplicationContext appContext = new XmlWebApplicationContext();
      
       MockServletContext servletContext = new MockServletContext(basePath);
       servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, appContext);

       if (shareContext)
       {
           servletContext.setAttribute(CONTEXT_PATH, appContext);
       }

       appContext.setServletContext(servletContext);
       appContext.setConfigLocations(locations);
       appContext.refresh();
       appContext.registerShutdownHook();

       Map<String, DispatcherServlet> map = appContext.getBeansOfType(DispatcherServlet.class);
       for (Entry<String, DispatcherServlet> entry : map.entrySet())
       {
           DispatcherServlet servlet = entry.getValue();
           String servletName = entry.getKey();
          
           if (shareContext)
               servlet.setContextAttribute(CONTEXT_PATH);
          
           MockServletConfig servletConfig = new MockServletConfig(servletContext, servletName);
           servlet.init(servletConfig);
       }

       return appContext;
   }
}

Now the class to call the dispatcher and perform the test:


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:/common-beans.xml", "classpath:/myservlet-test.xml" }, loader = WebAppLoader.class)
public class MyServletTester
{
   /** TILES_STACK. */
   private static final String TILES_STACK = "org.apache.tiles.AttributeContext.STACK";
   protected final Logger log = Logger.getLogger(getClass());
   /** the servlet */
   @Autowired
   protected DispatcherServlet servlet;
   /** user session info, session scoped. */
   @Autowired
   protected UserSession userSession;
   /** request scoped bean */
   protected MessageList messages;
   /** */
   protected MockHttpServletRequest request;
   /** */
   protected MockHttpServletResponse response;
   /** special util extending RequestDispatcher to capture forward() data. */
   protected RequestCopyingDispatcher requestDispatcher = new RequestCopyingDispatcher();

   public void onStart() throws Exception
   {
       request = null;
       response = null;
       // obtain bean stored in the servlet's own context
       messages = (MessageList) servlet.getWebApplicationContext().getBean("messages");
   }

/**
 * Perform the actual test.
 */
   @Test
   public void welcomePageLoggedIn() throws Exception
   {
       HashMap<String, String> parameters = new HashMap<String, String>();
       MockHttpServletResponse ret = process("/home.do", parameters, true);
       checkTilesResponse(response, request, "/jsp/tiles/mainLayout.jsp", "/jsp/welcomePage.jsp");
   }
  
   protected MockHttpServletResponse process(String uri, Map<String, String> reqParams, boolean loggedIn)
           throws Exception
   {
       MockInterceptingRequest req = new MockInterceptingRequest("GET", uri);
       MockHttpServletResponse res = new MockHttpServletResponse();
       req.setRequestDispatcher(requestDispatcher);

       //used for accessing request scoped proxied beans
       WebRequest webRequest = new ServletWebRequest(req, res);
       RequestContextHolder.setRequestAttributes(webRequest);

       req.addParameters(reqParams);
       HttpSession session = req.getSession();
       if (loggedIn)
       {
           //set properties to indicate logged in
       }

       //call
       servlet.service(req, res);

       response = res;
       request = req;
       //done
       return res;
   }

   public void checkResponse(MockHttpServletResponse response, MockHttpServletRequest request)
           throws Exception
   {
       assertThat("ret", response, notNullValue());
       assertThat("status code", response.getStatus(), equalTo(200));
       assertThat("getErrorMessage", response.getErrorMessage(), nullValue());
       assertThat("redirect", response.getRedirectedUrl(), nullValue());
   }

/**
 * Checks the response and request of the call.
 */
   public void checkTilesResponse(MockHttpServletResponse response, MockHttpServletRequest request,
           String template, String page) throws Exception
   {
       checkResponse(response, request);

       assertThat("forward", response.getForwardedUrl(), equalTo(template));

       //Attributes from the dispatcher tiles calls
       Stack tilesStack;
       tilesStack = (Stack) requestDispatcher.getCapturedAttributes().get(TILES_STACK);
       assertThat(TILES_STACK, tilesStack, notNullValue());
       assertThat("stack.isEmpty", tilesStack.isEmpty(), not(equalTo(true)));
       if (log.isDebugEnabled())
           log.debug(Arrays.toString(tilesStack.toArray()));
      
       BasicAttributeContext tilesContext = (BasicAttributeContext) tilesStack.pop();
       if (log.isDebugEnabled())
           log.debug(toString(tilesContext));
      
       assertThat("tiles.body", tilesContext.getAttribute("body"), notNullValue());
       String body = (String) tilesContext.getAttribute("body").getValue();
       assertThat("body", body, equalTo(page));
   }

   protected void debugAttributes()
   {
       Enumeration<String> names = request.getAttributeNames();
       while (names.hasMoreElements())
       {
           String name = names.nextElement();
           log.debug(name + ":" + request.getAttribute(name));
       }
   }

   public static String toString(BasicAttributeContext cntx)
   {
       StringBuilder sb = new StringBuilder();
       sb.append("TilesAttributes: {");

       Iterator<String> i = cntx.getAttributeNames();
       boolean hasNext = i.hasNext();
       while (hasNext)
       {
           String key = i.next();
           Attribute value = cntx.getAttribute(key);
           sb.append(key);
           sb.append("=");
           sb.append(value);
           hasNext = i.hasNext();
           if (hasNext)
               sb.append(", ");
       }

       sb.append("}");
       return sb.toString();
   }   
}

Getting sql parameters from CallableStatementCreatorFactory

2008-12-03T05:56:00.011+11:00

I had a massive headache trying to work out what data was passed to a procedure call that was using Spring's JdbcTemplate. The problem was, the parameters can be passed in as a map, so all you have is a set of names and value with no idea what order they go in. If you have a lot of statements to sift through then manually rebuilding the sql to execute is a pain.

After trying many times to work out a way to extend CallableStatementCreatorFactory in order to pull out the information to build an sql statement I eventually reverted to just replacing the whole source file.
Below is the resulting file, with date formatting (and select from dual) directed towards Oracle. Still useful for other vendors as it's pretty simple to adjust. I have no idea why this or something like it wasn't included in spring.

/*
 * Copyright 2002-2006 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.jdbc.core;
 
import java.math.BigDecimal;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
 
import org.apache.log4j.Logger;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor;
 
/**
* Helper class that can efficiently create multiple CallableStatementCreator objects with different
* parameters based on a SQL statement and a single set of parameter declarations.
*
* CW: updated to include debug which outputs an excutable sql statement with parameters substituted
*
* @author Rod Johnson
* @author Thomas Risberg
* @author Juergen Hoeller
* @author Chris Watts
*/
public class CallableStatementCreatorFactory
{
   private static final Logger logger = Logger.getLogger(CallableStatementCreatorFactory.class);
 
   /** The SQL call string, which won't change when the parameters change. */
   private final String callString;
 
   /** List of SqlParameter objects. May not be <code>null</code>. */
   private final List declaredParameters;
 
   private int resultSetType = ResultSet.TYPE_FORWARD_ONLY;
 
   private boolean updatableResults = false;
 
   private NativeJdbcExtractor nativeJdbcExtractor;
 
   /**
    * Create a new factory. Will need to add parameters via the addParameter() method or have no
    * parameters.
    */
   public CallableStatementCreatorFactory(String callString)
   {
       this.callString = callString;
       this.declaredParameters = new LinkedList();
   }
 
   /**
    * Create a new factory with sql and the given parameters.
    *
    * @param callString
    *            the SQL call string
    * @param declaredParameters
    *            list of SqlParameter objects
    */
   public CallableStatementCreatorFactory(String callString, List declaredParameters)
   {
       this.callString = callString;
       this.declaredParameters = declaredParameters;
   }
 
   /**
    * Add a new declared parameter. Order of parameter addition is significant.
    */
   public void addParameter(SqlParameter param)
   {
       this.declaredParameters.add(param);
   }
 
   /**
    * Set whether to use prepared statements that return a specific type of ResultSet.
    *
    * @param resultSetType
    *            the ResultSet type
    * @see java.sql.ResultSet#TYPE_FORWARD_ONLY
    * @see java.sql.ResultSet#TYPE_SCROLL_INSENSITIVE
    * @see java.sql.ResultSet#TYPE_SCROLL_SENSITIVE
    */
   public void setResultSetType(int resultSetType)
   {
       this.resultSetType = resultSetType;
   }
 
   /**
    * Set whether to use prepared statements capable of returning updatable ResultSets.
    */
   public void setUpdatableResults(boolean updatableResults)
   {
       this.updatableResults = updatableResults;
   }
 
   /**
    * Specify the NativeJdbcExtractor to use for unwrapping CallableStatements, if any.
    */
   public void setNativeJdbcExtractor(NativeJdbcExtractor nativeJdbcExtractor)
   {
       this.nativeJdbcExtractor = nativeJdbcExtractor;
   }
 
   /**
    * Return a new CallableStatementCreator instance given this parameters.
    *
    * @param inParams
    *            List of parameters. May be <code>null</code>.
    */
   public CallableStatementCreator newCallableStatementCreator(Map inParams)
   {
       return new CallableStatementCreatorImpl(inParams != null ? inParams : new HashMap());
   }
 
   /**
    * Return a new CallableStatementCreator instance given this parameter mapper.
    *
    * @param inParamMapper
    *            ParameterMapper implementation that will return a Map of parameters. May not be
    *            <code>null</code>.
    */
   public CallableStatementCreator newCallableStatementCreator(ParameterMapper inParamMapper)
   {
       return new CallableStatementCreatorImpl(inParamMapper);
   }
 
   /**
    * CallableStatementCreator implementation returned by this class.
    */
   private class CallableStatementCreatorImpl implements CallableStatementCreator, SqlProvider,
           ParameterDisposer
   {
 
       private ParameterMapper inParameterMapper;
 
       private Map inParameters;
 
       /**
        * Create a new CallableStatementCreatorImpl.
        *
        * @param inParamMapper
        *            ParameterMapper implementation for mapping input parameters. May not be
        *            <code>null</code>.
        */
       public CallableStatementCreatorImpl(ParameterMapper inParamMapper)
       {
           this.inParameterMapper = inParamMapper;
       }
 
       /**
        * Create a new CallableStatementCreatorImpl.
        *
        * @param inParams
        *            list of SqlParameter objects. May not be <code>null</code>.
        */
       public CallableStatementCreatorImpl(Map inParams)
       {
           this.inParameters = inParams;
       }
 
       public CallableStatement createCallableStatement(Connection con) throws SQLException
       {
           // If we were given a ParameterMapper - we must let the mapper do its thing to create the Map.
           if (this.inParameterMapper != null)
           {
               this.inParameters = this.inParameterMapper.createMap(con);
           }
           else
           {
               if (this.inParameters == null)
               {
                   throw new InvalidDataAccessApiUsageException(
                           "A ParameterMapper or a Map of parameters must be provided");
               }
           }
 
           CallableStatement cs = null;
           if (resultSetType == ResultSet.TYPE_FORWARD_ONLY && !updatableResults)
           {
               cs = con.prepareCall(callString);
           }
           else
           {
               cs = con.prepareCall(callString, resultSetType, updatableResults ? ResultSet.CONCUR_UPDATABLE
                       : ResultSet.CONCUR_READ_ONLY);
           }
 
           // Determine CallabeStatement to pass to custom types.
           CallableStatement csToUse = cs;
           if (nativeJdbcExtractor != null)
           {
               csToUse = nativeJdbcExtractor.getNativeCallableStatement(cs);
           }
 
           int sqlColIndx = 1;
           ArrayList<Object> parameterValues = new ArrayList<Object>();
           for (int i = 0; i < declaredParameters.size(); i++)
           {
               SqlParameter declaredParameter = (SqlParameter) declaredParameters.get(i);
               if (!declaredParameter.isResultsParameter())
               {
                   // So, it's a call parameter - part of the call string.
                   // Get the value - it may still be null.
                   Object inValue = this.inParameters.get(declaredParameter.getName());
                   if (declaredParameter instanceof ResultSetSupportingSqlParameter)
                   {
                       // It's an output parameter: SqlReturnResultSet parameters already excluded.
                       // It need not (but may be) supplied by the caller.
                       if (declaredParameter instanceof SqlOutParameter)
                       {
                           parameterValues.add(null);// out parameters
                           if (declaredParameter.getTypeName() != null)
                           {
                               cs.registerOutParameter(sqlColIndx, declaredParameter.getSqlType(),
                                       declaredParameter.getTypeName());
                           }
                           else
                           {
                               if (declaredParameter.getScale() != null)
                               {
                                   cs.registerOutParameter(sqlColIndx, declaredParameter.getSqlType(),
                                           declaredParameter.getScale().intValue());
                               }
                               else
                               {
                                   cs.registerOutParameter(sqlColIndx, declaredParameter.getSqlType());
                               }
                           }
                           if ((declaredParameter).isInputValueProvided() || inValue != null)
                           {
                               StatementCreatorUtils.setParameterValue(csToUse, sqlColIndx,
                                       declaredParameter, inValue);
                           }
                       }
                   }
                   else
                   {
                       // It's an input parameter- must be supplied by the caller.
                       if (!this.inParameters.containsKey(declaredParameter.getName()))
                       {
                           throw new InvalidDataAccessApiUsageException("Required input parameter '"
                                   + declaredParameter.getName() + "' is missing");
                       }
                       StatementCreatorUtils.setParameterValue(csToUse, sqlColIndx, declaredParameter,
                               inValue);
                       parameterValues.add(inValue);// out parameters
                   }
                   sqlColIndx++;
               }
           }
 
           if (logger.isDebugEnabled())
           {
               logger.debug(buildCallableSql(callString, parameterValues));
           }
           return cs;
       }
 
       public String getSql()
       {
           return callString;
       }
 
       public void cleanupParameters()
       {
           if (this.inParameters != null)
           {
               StatementCreatorUtils.cleanupParameters(this.inParameters.values());
           }
       }
 
       public String toString()
       {
           StringBuffer buf = new StringBuffer(
                   "CallableStatementCreatorFactory.CallableStatementCreatorImpl: sql=[");
           buf.append(callString).append("]; parameters=").append(this.inParameters);
           return buf.toString();
       }
   }
 
   private static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
 
   public static String buildCallableSql(String sql, List<Object> orderedParams)
   {
       //StringBuilder sb = new StringBuilder(sql);
       String sqlStr = sql;
       if (sqlStr.startsWith("{? = call "))
       {
           //remove first (output parameter)
           orderedParams.remove(0);
           sqlStr = sqlStr.substring("{? = call ".length());
           sqlStr = sqlStr.substring(0, sqlStr.length() - 1);
           sqlStr = "select " + sqlStr + " from dual;";
       }
       for (Object val : orderedParams)
       {
           String value;
           if (val == null)
               value = "null";
           else if (val instanceof String)
               value = "'" + ((String) val).replace("'", "''") + "'"; //escape
           else if (val instanceof Date)
               value = "TO_DATE('" + dateFormat.format((Date) val) + "', 'YYYY/MM/DD HH24:MI:SS')";
           else if (val instanceof Integer || val instanceof Long || val instanceof BigDecimal
                   || val instanceof Double)
               value = val.toString().replace("'", "''"); //escape
           else
               value = "'" + val.toString().replace("'", "''") + "'"; //escape
 
           sqlStr = sqlStr.replaceFirst("[?]", value);
       }
       return sqlStr;
   }
}

Hibernate's Criteria API

2008-11-26T02:27:00.009+11:00

Hibernate has a Criteria API which allows you to dynamic build up filter conditions and set various join options. It is perfectly suited for flexible searches on entities, however there are areas in falls down in and the documentation is scarce.
Criteria instances can be either created from the hibernate Session or a DetachedCriteria can be created for later execution or for passing into Spring's HibernateTemplate.

The first thing that is explicitly mentioned is that references to properties can only be one deep, properties on child entities must be mapped via createAlias / createCriteria call. For example, the following will give a "org.hibernate.QueryException: could not resolve property: child.property of: com.example.model.Parent".

DetachedCriteria criteria = DetachedCriteria.forClass(Parent.class,"parent");
criteria.add(Restrictions.eq("parent.child.property", "somevalue");

Instead the child entity must be explicitly join by calling the following:

DetachedCriteria criteria = DetachedCriteria.forClass(Parent.class,"parent");
criteria.createAlias("parent.child","thechild");
criteria.add(Restrictions.eq("thechild.property", "somevalue");

Creating a join is not nesecary, if just the identifier is being referenced:

DetachedCriteria criteria = DetachedCriteria.forClass(Parent.class,"parent");
criteria.add(Restrictions.eq("parent.child.id", 1);

Add an IN condition.
To add a "where field in subquery", two separate criteria are required. One for the main (root) entity, and the other to retrieve the values for the IN list.
The following retrives the orders for which it has an order item which the product has a stock level of ZERO. The result transformer is used to only retrieve one row per entity, instead of having multiple rows as a result of the join on a one-to-many relationship.

DetachedCriteria ids = DetachedCriteria.forClass(ProductStock.class, "stock");
ids.add(Restrictions.eq("stock.stockLevel", 0));
ids.setProjection(Property.forName("productId"));

DetachedCriteria criteria = DetachedCriteria.forClass(Order.class, "order");
criteria.createAlias("order.orderItems", "items", CriteriaSpecification.LEFT_JOIN);
criteria.add(Subqueries.propertyIn("items.productId", ids));
criteria.setResultTransformer(Criteria.ROOT_ENTITY);

Performing a WHERE EXISTS
An exists is a variation on the above query, sometimes useful when the join could be large, or when it simply results in a faster execution.

DetachedCriteria ids = DetachedCriteria.forClass(ProductStock.class, "stock");
ids.add(Restrictions.eqProperty("stock.productId", "items.productId"));
ids.add(Restrictions.eq("stock.stockLevel", 0));

DetachedCriteria criteria = DetachedCriteria.forClass(Order.class, "order");
criteria.createAlias("order.orderItems", "items", CriteriaSpecification.LEFT_JOIN);
criteria.add(Subqueries.exists(ids));

However you cannot do arbitrary joins between 2 unassociated tables. All associations have to be defined in the mapping files before a criteria can be joined (i.e. a createAlias), the IN and EXISTS are the only other alternative.
There are other limitations which I have had to circumvent by either doing extra set mappings or extending Hibernate's classes.

Hibernate's Lazy Loading Quirks

2008-11-19T04:04:00.005+11:00

I have come across two problems which have caused me no end of grief which turned out to be pretty simple.

LazyInitializationException
When using the Spring OpenSessionInViewFilter, I refer to lazily initialised properties (mapped as many-to-one or one-to-one) in the JSP pages. However I was getting a scenario where if a user performed a certain action I would get the following error:

org.hibernate.LazyInitializationException: could not initialize proxy - no Session

After a lot of debugging and sifting through hibernate's source I traced it to a bit of code I had used that someone had posted for having a paged interval collection for hibernate (as oracle doesn't support server side paging). The culprit line of code was:

hibernateTemplate.clear();

//which is defined in Spring's wrapper as
public void clear() throws DataAccessException {
executeWithNativeSession(new HibernateCallback() {
  public Object doInHibernate(Session session) {
      session.clear();
      return null;
  }
});
}

This causes all objects that had been loaded previously by that session to be DISCONNECTED from the session. Hence the slightly misleading message. The session is still open, its just longer associated with it.

many-to-one relationships not being lazy
I had a problem with relationships which I had defined as being lazy not being lazily loaded which I only discovered after I turned of the second level cache off. With the cache on, I never saw the requests it made internally to load an entire child-parent-etc hierarchy (which is one bonus of using a cache).
After spending what seemed like hours, sifting through the documentation on lazy loading, fiddling with settings, checking the bytecode libraries, I finally discovered the cause. To get around cases where the 'static' data that these entities were referring to were missing due to some muppet bodging the data, I had set attribute not-found="ignore". This prevents the JSP page blowing up when you try and access the property when all you really want is to display a blank field or maybe a message. However, in order for a relational property to be lazy loaded it must be set to not-found="exception" (which is the default). Its a trade off between dealing with the exceptions where you don't expect them and the performance hit.

EasyMock and Spring Autowiring

2008-11-17T20:50:00.032+11:00

Spring Framework provides an easy way to unit test components in isolation and EasyMock provides a quick way to create mock objects with very little effort. Combining them together, Spring can be used to create the mock objects so that beans that use auto wiring to inject dependencies can be tested without having to modify the classes or create complex context configuration files.

Creating mock objects using spring is simple, here is a sample beans.xml:

<bean class="org.easymock.EasyMock" factory-method="createNiceMock" primary="true" id="someServiceMock">
   <constructor-arg value="com.example.service.SomeService" />
</bean>

This creates a mock object from the given interface. The primary is used to indicate that it should be used for autowiring which is useful when component scanning is used together with @Component tags. When you want to refer to the actual implementation you would use @Qualifier("someService").

If interfaces aren't used then the following beans.xml is used.

<bean class="org.easymock.classextension.EasyMock" factory-method="createNiceMock" primary="true" id="someDAO" >
   <constructor-arg value="com.example.dao.SomeDAO" />
   <property name="sessionFactory">
      <null />
   </property>
</bean>

Performing the test is relatively simple and with autowiring configuration is minimal. Below I have used the classextension static imports as it can be used for both types of mocks. However the standard expect/replay/etc cannot be used with classextension created mocks.

import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.reset;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import org.junit.Before;
import org.junit.Test;
import org.springframework.ui.ModelMap;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:/controller-beans.xml" })
public class TestSampleController
{
   /** UNIT UNDER TEST */
   @Autowired
   private SampleController controller;
   /** mock object */
   @Autowired
   private SampleService service;

   /**
   * Called before each test.
   */
   @Before
   public void setUp() throws Exception
   {
      reset(service);
   }

   @Test
   public void testPage() throws Exception
   {
      //data
      List data = new LinkedList();

      //prepare
      expect(service.getData()).andReturn(data);
      replay(service);

      //perform
      ModelMap map = new ModelMap();
      String result = controller.page(map);

      //verify
      assertThat("result", result, equalTo("expected");
      assertThat((Map<String,Object>) map, Matchers.hasKey("someobj"));
      assertThat("someobj", map.get("someobj"), notNullValue());
   }
}

Finally there are cases where you need the mock object ready to give a response during load up, such as in an InitializingBean. In those cases the following util class can be adapted:

public class MockUtil
{
   public static <T> T createNiceMock(Class<T> toMock, boolean replay)
   {
      IMocksControl control = EasyMock.createNiceControl();
      T mock = control.createMock(toMock);
      if (replay)
      {
         control.replay();
      }
      return mock;
   }
}

<bean id="dataServiceMock" class="com.example.test.MockUtil"  factory-method="createNiceMock" primary="true">
   <constructor-arg value="com.example.service.DataService" />
   <constructor-arg value="true"/>
</bean>