C[omp]ute

From: "andrew cooke" <andrew@...>

Date: Wed, 20 Aug 2008 16:25:55 -0400 (CLT)

At work I'm writing code to provide a REST interface to a database (really
it's simpler than that - it's read only).  In the controller I want to
automate the construction of the model as much as possible.  This is
driven by the parameters in the request, so as a first step I want to be
able to set object attributes from the HTTP request.

I also want to be able to generate URLs from these same objects, when they
are modified (so that it is easy to generate URLs in the view to related
information).

So I need to (1) associate attributes with HTTP requests and (2) store
default parameters (so that the generated URI is no longer than
necessary).  After wondering exactly how to go about this I remembered the
rather excellent approach taken by args4j - https://args4j.dev.java.net/ -
which uses annotations on attributions.

It turns out that this is incredibly easy to do.  I now have some simple
annotations that let me define a tree of objects that will be
automatically generated with attributes populated from the request (which
tree is generated will depend on some other logic using the URI).

Here's the test (this is work's code, so it's (c) ISTI http://www.isti.com
and available under an attribution-based licence; contact ISTI for full
details).

public class BuilderTest
{

  @Test
  public void testAll()
  throws IllegalArgumentException, SecurityException, InstantiationException,
  IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    MockHttpServletRequest request = new MockHttpServletRequest();
    request.setParameter("value-1", "one");
    request.setParameter("value-3", "3");
    request.setParameter("value-a", "a");
    request.setParameter("value-b", "5");
    Builder builder = new Builder(request);
    Outer outer = builder.build(Outer.class);
    assertEquals("Bad value for value1", "one", outer.value1);
    assertEquals("Bad value for value2", "default", outer.value2);
    assertEquals("Bad value for value3", 3, outer.value3);
    assertEquals("Bad value for valuea", "a", outer.inner.valuea);
    assertEquals("Bad value for valueb", 5, outer.inner.valueb, 0.001);
  }

  public static class Outer {
    @Parameter(deflt = "", name = "value-1")
    public String value1;
    @Parameter(deflt = "default", name = "value-2")
    public String value2;
    @Parameter(deflt = "", name = "value-3")
    public int value3;
    @Parameterised
    public Inner inner;
  }

  public static class BaseInner {
    @Parameter(deflt = "", name = "value-a")
    public String valuea;
  }

  public static class Inner extends BaseInner {
    @Parameter(deflt = "", name = "value-b")
    public double valueb;
  }

}

And you can see that:
1 - attributes are set from the HTTP request
2 - defaults are supplied as necessary
3 - a tree of objects can be created

The implementation is simple (the annotations themselves are trivial
interfaces).  All the work is done in the Builder, mainly in these
methods:

public <Type> Type build(final Class<Type> clazz)
{
  Type instance = clazz.getConstructor().newInstance();
  // if we use getDeclaredFields here we don't superclass fields.
  // unfortunately, this then restricts us to public fields (declared
  // seems to also include protected fields)
  for (Field field: clazz.getFields()) {
    setParameter(instance, field);
    extendParameterised(instance, field);
  }
  return instance;
}

private <Type> void setParameter(final Type instance, final Field field)
{
  logger.debug("Field {}", field.getName());
  Parameter parameter = field.getAnnotation(Parameter.class);
  if (parameter != null) {
    String value = getValue(parameter);
    if (field.getType() == String.class) {
      field.set(instance, value);
    } else if (field.getType() == Integer.TYPE) {
      field.setInt(instance, Integer.parseInt(value));
    } else if (field.getType() == Double.TYPE) {
      field.setDouble(instance, Double.parseDouble(value));
    } else {
      throw new BadParameterException(
        String.format("Bad type %s for %s = %s.",
                      field.getType().getSimpleName(),
                      parameter.name(), value));
    }
  }
}

private <Type> void extendParameterised(
    final Type instance, final Field field)
{
  if (field.isAnnotationPresent(Parameterised.class)) {
    field.set(instance, build(field.getType()));
  }
}

Andrew