Jeroen Wyseur

Devoxx 2010

2010-11-18T15:02:00.000+01:00

Only one day at devoxx 2010 because I'm in between clients. Two days at the new client, one day devoxx and two days at the old client, a nice compromise.

My feelings of the first conference day were:
Keynotes
JavaSE7 will be released mid 2011 and does not include that much (since 6 is from december 2006 ...), the most interesting being project coin and DynamicInvoke. The rest of the features as project lambda and jigsaw will have to wait till 8.
The "State of the web" presentation gave great insights about what the web needs. An app store as the one mozilla is preparing would be nice and HTML5 being a real standard instead of a grouping of features which is different for every browser.

JPA2
A lot of new stuff but most of it was already in some form in Hibernate so it just seems to me I will be using less hibernate specific things. The pessimistic locking, I didn't know about and seems to be interesting for the cases where database locking is needed. Something to remember when the need arrises ...

Infinispan
An interesting data grid but I don't seem to be using those. I wonder who does but didn't get an answer on that.

Vaadin
A great Server side RIA based on top of GWT. Because of the number of components, you won't need much else. I would use it if I needed a desktop like app in the browser. Another thing to remember if that use case pops up.

Spring (3.1 and caching)
Two sessions that I can combine. The first one a nice overview of 3.0 (already available) and 3.1 (Spring 2011 - would also be a nice name!). I like the annotations a lot. I depends on what you prefer but having the code and the configuration in one place is very important for me.
The last session was about the cache abstraction that will be available in 3.1. Spring is only a mediator between your application and the actual caching provider and allows you to determine what to cache (with what key) and what to evict. Putting the @Cachable annotation will make you think about what it means to have that cached. Apparently cache misses are something to be feared!

Mocking properties in struts using mockrunner

2010-02-19T14:40:00.004+01:00

I didn't find any example on how to use com.mockrunner.struts.MapMessageResourcesFactory class. So here we go:


Map<string, string> resources = new HashMap<string, string>();
resources.put("TEST", "TEST_MESSAGE");
resources.put("TEST2", "TEST_MESSAGE2");
MapMessageResourcesFactory.setMessageMap(resources);
MessageResourcesFactory.setFactoryClass("com.mockrunner.struts.MapMessageResourcesFactory");

The last line makes sure that when the message resources are loaded using


MessageResources.getMessageResources("PropertiesFile");

that the given map is used to represent the resource bundle.

Hibernate validation

2010-01-05T10:29:00.004+01:00

While using dbunit for unit testing, we disabled the database constraint validation, making it possible to create the database rows in the wrong order or not filling in fields if they are not needed for the test. I would recommend dbunit to anyone who wants to run tests with a database (the long-running kind of tests you want to include in your nightly build, not the continuous).

Then we ran into the problem that hibernate does its own validation based on for example a @NotNull annotation you placed inside your model giving one of the following exceptions:

org.hibernate.PropertyValueException: not-null property references a null or transient value: your.domain.Object.nonNullField
org.hibernate.validator.InvalidStateException: validation failed for: your.domain.Object

This can be fixed by disabling this kind of checks in the persistence unit using the following properties:


<property name="hibernate.validator.apply_to_ddl" value="false"/>
<property name="hibernate.validator.autoregister_listeners" value="false"/>

Devoxx Day Five and summary

2009-11-19T16:27:00.002+01:00

Last day already. First about the sessions I followed:

"BPM on a SOA environment" The difference I noticed earlier between BPM & BPEL, has a name, the difference between managed and unmanaged process. The presentation tackled the problems between reality and how to reflect in BPM (don't forget the error handling!) At total architecture, you can read more about it.
"Towards a universal VM" The JVM start to integrate features in its JIT compilation, not for the Java language but for dynamic languages on top of it. The presented feature was invokedynamic.
Archimate tries to bridge between the free format boardroom type models and very specific UML models. It focused on Enterprise Architects and integrating different high level views.

For me the main topics where cloud computing and service-orientation (don't say SOA anymore). Both are still not there yet but further maturing.

Devoxx Day Four - part 2

2009-11-19T14:56:00.006+01:00

The "JavaFX in the enterprise" session showed a lot of the JFXtras project which is a step in the right direction but I think still a lot of work has to be done to make JavaFX usable in the enterprise.

The iBeans framework offers easy integration without using a full SOA. Simplifies the development of a small app/widget with integrates a lot. I found it a bit annotation heavy.

Glassfish v3 I saw already the previous time at Devoxx. Still an impressive application server, I will surely check it out when it comes out 10/12/2009. Before the demo, Roberto Chinnci explained a bit the extensability of JavaEE 6 at servlet level through ServletContainerInitializer subclasses and the dependency injection through an Extension implementation. I won't go into details but basically, you can by adding a jar to your classpath, dynamically add servlets, servlets and beans when the app starts up. Very powerful and a blessing for the common developer onces the frameworks start using this. No more configuration but pure magic.

Last session performance. I have to agree with the speaker which is from IBM Support Assistant. Performance is only an issue when it's bad. The techniques explained for finding CPU, I/O, memory of lock problems often involved some sort of tool. Still experience in understanding the returned data is often more important than the used tool.

Devoxx Day Four - part 1

2009-11-19T13:23:00.007+01:00

The keynote of today was very good with speakers focussing on a foundation of developing software (Ivar Jacobson) and craftmanship (uncle bob). The foundation was alot about how to define a base which could be extended by different practices instead of reinventing the whole process each time. The SEMAT initiative was started to do just this. Craftmanship is all about being proud of your work and behaving like a professional. I have already read the clean code book and while I found it to be repeating, the points are valid.

First real session, "Using XML for Java" by Michael Kay gave a good overview of how to handle that damn XML. From low to high level :

Event processing (SAX/STAX) : use when high performance is needed and schema remains fixed.
Tree based : certainly don't use the standard DOM but JDOM, DOM4J or the newest kid around the block XOM.
Data binding (JAXB and others): only when conversion is needed!
XSLT/XQuery : higher level language to handle XML.

The speaker would like us to have an all XML application where Java is the glue/infrastructure. From an XML database through a XSLT/XQuery pipeline to an XForms frontend. Sounds nice but since XSLT/XQuery is a specific language, I don't believe it has the same flexibility. I can agree that if not needed (XML is input and output), don't map the XML to Java but use conversion.

I followed a quickie about fluent languages (internal DSL) just a better way to write an API. Examples can be found in the fluent validation framework. Try writing you own, it's a lot of fun.

Devoxx Day Three - part 2

2009-11-18T16:44:00.009+01:00

After a few technical problems, the "SLF4J and logback" session started. I have to say, I'm impressed that so much could be improved. Some highlights:
SLF4J a commons-logging replacement:

Parameterized logging: replacing the if (logger.isDebugEnabled()) guard clause by a smarter method logger.debug("Hello {}", name) which is fast. Three lines to one!
Easy logging backend selection by just putting the right jar in the path. No more searching why what backend was selected.

Logback : a log4j replacement

Very nice configuration which is easy extensible. Builds on dependency injection.
Easy filtering on log statements using evaluations.
SiftingAppender: multiple files based on an evaluation
Stack traces contain jar file and its version number.

Migration is made easy by a migrator tool. Seems really terrific. It also has an eclipse plugin to read the logfiles better than with the standard console view. Should you migrate? I think so.

A very crowded session with a very long title, "Traditional Programming Models: Knives and bearskins in the google age", had some nice points but didn't do anything with them. Like programming concepts as ordered , reliable and only once execution are very expensive in a distributed environment as messaging and databases. So it is normal that scaling is difficult. But further no real answers ...

"Solr: power to lucene" was a more interesting session. Solr is a compelling product if you need search. A bit too much bullet points in the presentation about what Solr can do. Just saying 'get a great "google like" search for the documents/databases/... you add to it' says almost the same.

Last session of the day 'Animation Rules! A fun session telling a lot about disney animation and its relation with the GUI world. Explains a bit why some things look good in a GUI. Examples: slow in/out, hover over for a button, ...

Devoxx Day Three - part 1

2009-11-18T12:19:00.004+01:00

In the keynote I learned:

Oracle is committed to Java (or at least wants to give us that message).
Java EE 6 will be great, as will GlassFish v3 and it's coming 10/12/2009.
Adobe wants developers to switch to their platform which has great tools to benefit the interaction between designers and developers. Definitely something to consider if you want a cool client app.

Then I followed the "ESB's & web services in practice" because I liked the previous talk of Nicolai Josuttis. Learned some things but still the talk looked a bit too much too the one of yesterday. SOA is a solution to a problem (how to connect heterogeneous systems) but not one without its own issues. It was a bit more in depth, discussing problems with ESB and WSDL instead of SOA in general. This showed to me that it is complicated and for example if you only have 5 systems, point to point could be preferable to an intermediate ESB. A pragmatic approach is probably the best. I remember doing routing of messages from and to different systems using just a plain appllication server without any other framework/tool/product. Using an ESB for just that would have been too much overhead.

Devoxx Day Two

2009-11-17T11:03:00.010+01:00

I wanted to start with the apache wicket session which was cancelled. So I ended up in a google app engine session. Seems very nice to get a small/personal app up in there however because of the restrictions placed (which seem fair to me), you will run in to unexpected problems here and there. They demonstrated a SpringMVC, JSF2 and GWT user interface on top of a common spring bean service layer using a JDO DAO layer. I think the presented application is interesting as a starting point since they encountered and fixed a number of gotchas. It looks like of the three, SpringMVC gave the least problems.

I tested a couple of weeks ago Google App Engine and tried to run grails on it. Worked fine with some tweaks but I couldn't get my JRebel to work with it but this is getting worked on. Look at this page to see if your favorite framework works on it. Apache Wicket doesn't so I have to find something else to know what this Wicket stuff is about ...

Next session "SOA in practice" by Nicolai Josuttis, apparently he also has a book about the topic. From all code session to a no code session. Very very interesting session which also confirmed my suspicions on BPEL the previous day. It should only be used for backend processes, not when user interaction is needed. He really doesn't like BPEL (probably had to work with too long) and raised valid points that vendors won't tell you:

You need to implement the services to be able to plug an play.
Implementing error handling is hard and takes 80% of your workflow.
It doesn't help you to handle your SLA (service level agreement)
Converting from UML, BPMN, EPC or visio to BPEL may work but the result will not be readable.

But that was not what the talk was about. You should only use SOA if you need it because of

distributed processes
on heterogenous systems (using different technologies)
with different owners.

and even then it will be hard. A large system that is tightly coupled may sound bad but loosely coupling and a lot of systems is complex. The gained flexibility comes at a price! Maintaining a landscape of systems instead of developing one system brings not only technical challenges but also organizational. You can't buy SOA!

After that he also talked about the SOA manifesto that he helped creating. While probably useful as communication instrument, it is too abstract for me.

Last sesion about "Gradle, a better way to build" or not because I left for the java monitor session which was quite interesting. A lot of garbage collector insights. A pity the session was so short but you can find the slides here. An interesting thing was that the server VM is faster than the client VM which starts up faster.
The gradle session I left because it seemed very complicated. I could as well use Ant which I know already instead of learning another complicated thing.

Devoxx Day One

2009-11-16T19:45:00.003+01:00

The first day of the Devoxx conference in Antwerp, I followed the sessions "jBPM 4 In Action" and "SOA, OpenESB & OpenSSO : Programming with Passion". During the second session I noticed that both sessions were somewhat related since they were both handling Business Processes and how the respective frameworks jBPM and OpenESB can help you to implement those.
However when I look at the two presentation, I notice that jBPM is more focused on high level business processes involving human interaction while OpenESB focuses more on the composition of a difficult service in different subservices probably provided by different parties. Maybe this is because the second talk was focused around the BPEL Service Engine (JBI component in OpenESB), if I look to the WLM Service Engine, I some more similarities with jBPM.
The jBPM engine saves the current state of the instance of the process, keeps historical data and provides statistics on this. I didn't see any of that on the OpenESB side. On the other hand, all this database stuff also means that a process that was already running when the process is updated, needs to be migrated to the new process. This issue has been taken care of for jBPM4.
Integrating for example a UI with jBPM has to be done with the jBPM API which seems to work quite natural. Integrating with a composite application of OpenESB has to be done through a kind of binding. Often this will be SOAP but also another one could be created.

Having no experience with any of these (however I played with both a couple of years ago), I would select jBPM if I would need to implement a process with a lot of human interaction (for example requesting/approving holidays) and I would choose OpenESB to integrate between different systems.

Timing information EJB3

2009-10-30T11:15:00.006+01:00

To test the performance of an application, a lot of complicated tools exist. And while they are very useful, often a pragmatic solution suffices to find the trouble spots. The suggestion below allows you to test the application and find out how long each EJB3 call took. The same could be done for any framework supporting interception of calls.

The EJB3 specification provides support for interceptors making it possible to time the execution of every EJB3 on the fly. The following code intercepts each EJB3 call and stores the timing information per thread in a static variable. The recording can be enabled and disabled using the logging configuration. Another dependency is the org.apache.commons.lang.time.StopWatch.


import org.apache.commons.lang.time.StopWatch;
import org.apache.log4j.Logger;

import javax.interceptor.AroundInvoke;
import javax.interceptor.InvocationContext;

import java.util.*;

public class TimerInterceptor {
private static final Logger LOG = Logger.getLogger(TimerInterceptor.class);

private static ThreadLocal<calltiming> callTrace = new ThreadLocal<calltiming>();

public static Vector<calltiming> recordedTimings = new Vector<calltiming>();

@AroundInvoke
public Object timeCall(InvocationContext context) throws Exception{
    Object returnValue;
    boolean infoEnabled = LOG.isInfoEnabled();
    try{
        String key = context.getTarget().getClass().getName() + "." + context.getMethod().getName();
        StopWatch watch = null;
        CallTiming timing = null;
        CallTiming parentTiming = null;
        if (infoEnabled){
            watch = new StopWatch();
            watch.start();
            parentTiming = callTrace.get();
            if (parentTiming == null) {
                timing = new CallTiming(key);
                callTrace.set(timing);
            } else {
                timing = parentTiming.getSubTiming(key);
                callTrace.set(timing);
            }
        }
        returnValue = context.proceed();
        if (infoEnabled){
            watch.stop();
            LOG.info("The call to " + key + " took " + watch + " seconds");
            timing.addTime(watch);

            if (parentTiming != null) {
                callTrace.set(parentTiming);
            } else {
                if (recordedTimings.size() > 20){
                    recordedTimings.removeAllElements();
                }
                recordedTimings.add(callTrace.get());
                callTrace.remove();
            }
        }
    }catch(Exception e){
        if (infoEnabled){
            LOG.error("Error was rethrown during timing -> no information was recorded.", e);
            callTrace.remove();
        }
        throw e;
    }
    return returnValue;
}

public static class CallTiming {
    String name;
    Set<stopwatch> timeSet = new HashSet<stopwatch>();
    List<calltiming> childCalls = new ArrayList<calltiming>();

    CallTiming(String name) {
        this.name = name;
    }

    CallTiming getSubTiming(String name) {
        if (!childCalls.isEmpty() && childCalls.get(childCalls.size() - 1).getName().equals(name)) {
            return childCalls.get(childCalls.size() - 1);
        } else {
            CallTiming timing = new CallTiming(name);
            childCalls.add(timing);
            return timing;
        }
    }

    void addTime(StopWatch watch) {
        timeSet.add(watch);
    }

    public String getName() {
        return name;
    }

    public Set<stopwatch> getTimeSet() {
        return timeSet;
    }

    public List<calltiming> getChildCalls() {
        return childCalls;
    }
}
}

Any EJB you want to record the information from an EJB you need to add @Interceptors(TimerInterceptor.class).

Then the recorded information can be read using a simple servlet like this:


import be.post.pla.util.TimerInterceptor;
import org.apache.commons.lang.time.StopWatch;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import java.util.Vector;

public class TimeInfoServlet extends HttpServlet {
 @Override
 protected void doGet(HttpServletRequest request,
                      HttpServletResponse response)
         throws ServletException, IOException {

     response.setContentType("text/html");
     PrintWriter writer = response.getWriter();

     Vector<timerinterceptor.calltiming> recordedTimings = TimerInterceptor.recordedTimings;
     writer.println("<title>Timings</title>");
     int i = 0;
     for (TimerInterceptor.CallTiming recordedTiming : recordedTimings) {
         writer.println("<h2>Recording" + i++ +"</h2>");
         writer.print("<p><b>");
         writer.print(recordedTiming.getName());
         writer.println("</b>");
         long subTotal = printChildCalls(writer, recordedTiming.getChildCalls());
         long total = 0;
         for (StopWatch stopWatch : recordedTiming.getTimeSet()) {
             total += stopWatch.getTime();
             writer.print(stopWatch);
             writer.print(", ");
         }
         writer.println("
Total time spent " + String.format("%.3fs", total / 1000d) + " seconds");
         writer.println("
of which " + String.format("%.3fs", subTotal / 1000d) + " seconds were in children calls");
     }
     writer.println("");
 }

 private long printChildCalls(PrintWriter writer, List<timerinterceptor.calltiming> calls) {
     long childrenTotal = 0;
     if (!calls.isEmpty()) {
         writer.println("</timerinterceptor.calltiming></p><ul>");
         for (TimerInterceptor.CallTiming call : calls) {
             writer.print("<li><b>");
             writer.print(call.getName());
             writer.print("</b> -- ");
             writer.print(call.getTimeSet().size());
             writer.println(" times");
             long subTotal = printChildCalls(writer, call.getChildCalls());
             long total = 0;
             if (call.getTimeSet().size() > 1) {
                 writer.print("
");
                 for (StopWatch stopWatch : call.getTimeSet()) {
                     total += stopWatch.getTime();
                     writer.print(stopWatch);
                     writer.print(", ");
                 }
             } else {
                 total = call.getTimeSet().iterator().next().getTime();
             }
             writer.println("
Total time spent " + String.format("%.3fs", total / 1000d) + " seconds");
             writer.println("
of which " + String.format("%.3fs", subTotal / 1000d) + " seconds were in child calls");
             writer.println("</li>");
             childrenTotal += total;
         }
         writer.println("</ul>");
     }
     return childrenTotal;
 }
}

Add that servlet to your web.xml :


   <servlet>
       <servlet-name>Timer</servlet-name>
       <servlet-class>***packagename***.TimeInfoServlet</servlet-class>
   </servlet>
   <servlet-mapping>
        <servlet-name>Timer</servlet-name>
        <url-pattern>/timer</url-pattern>
   </servlet-mapping>

Giving you some information as :

Recording0

xxx.ContractsFacadeBean.getPersonContracts
* xxx.ContractServiceBean.getPersonContracts -- 1 times
o xxx.ContractDAOBean.getPersonContracts -- 1 times
Total time spent 0,590s seconds
of which 0,000s seconds were in child calls
Total time spent 1,012s seconds
of which 0,590s seconds were in child calls
0:00:05.178,
Total time spent 5,178s seconds
of which 1,012s seconds were in children calls

Concurrency ...

2009-09-22T16:25:00.006+02:00

Most java developers don't know a thing about concurrency other than there is a synchronized keyword that can be applied and that does some magic. The pity is that it doesn't always does it's magic and little is understood why. As web developer, I admit that concurrency is a weak point. The only times I see it used is when self-implementing a cache what you shouldn't do anyway. For the rest, if you keep yourself to JavaEE standards as not using fields in session beans or servlets, you should be safe. (I think and hope!)

I happened to work on some swing code and work together with a swing developer, there concurrency is something that you have to know. The last book I read ("Clean Code") also talked a bit about concurrency and then I started reading the Sun tutorial.

I learned to use more of the provided framework instead of inventing the wheel yourself:

Thread-safe collections such as ConcurrentHashMap. Very useful if you have some kind of cache instead of using synchronized all over the place and hope for the best.
Use Executors and swingworkers instead of dealing with threads yourself.

Some other concurreny tips from Joshua Bloch, Brian Goetz and others.

Using hibernate custom types to make a better domain model

2009-08-14T16:01:00.003+02:00

When designing a domain model, it is good practice to encapsulate business types in their own class to be able to add specific methods to type. This avoids having some helper class around that contains these methods but is not found by every programmer. Some examples:

The social security number of a person is stored in the database as a string but should be represented in its own SSN class.
A month can be represented in the database as a number containing for example 200907. Encapsulating this in a Month class makes it possible to add comparison methods or for example a nextMonth() method.
A bank account number is stored as a string. Encapsulating this makes sure it is a valid bank account.

The problem here is that when retrieving this from the database, a string or number is retrieved which doesn't hold the same meaning. A possible solution is to store it as a String internally but use the right class when showing it to the outside. This still means that the mapping needs to be done internally too and needs to be copied to every place where this type is used.

A better solution is to instruct hibernate how to do the conversion by implementing org.hibernate.usertype.UserType and adding the @TypeDef and @Type annotations. A nice article about how to actually implement this can be found here.

For Java5 enumerations using the the EnumUserType or this solution if the value in the database is different than the enumeration.

Casting hibernate proxies to subclasses

2009-06-29T07:59:00.006+02:00

For a hibernate entity with subclasses like the
following:

When retrieving all addresses, hibernate can return a list of proxies instead of the real addresses (something more about proxies). These proxies, subclass Address and not the HomeAddress or WorkAddress class that they could represent. This results in the following exception when casting to HomeAddress or WorkAddress:

java.lang.ClassCastException: package.Address_$$_javassist_36

The solution is to deproxy the classes before casting them as follows:

if (type instanceof HibernateProxy)
type = Address .class.cast(((HibernateProxy) type).getHibernateLazyInitializer().getImplementation());
else
type = Address .class.cast(type);

I ran into this problem when hibernate fetched a list of all rows of one table (some 25 records) and somehow manages to provide actual classes for a number of those and proxies for the rest. If somebody could explain me why it doesn't retrieve all classes (or all proxies), I would be very happy.

really using wadl2java

2009-05-09T16:22:00.001+02:00

I recently tried out the wadl2java code generator, together with some simple test REST service written with Jersey. Jersey provides after deployment a Web Application Description Language (WADL) and using that wadl2java generates a client to access that REST service. The generated WADL has version number 1.0 thus also that generator is needed. Further information about WADL versions can be found on the wadl2java web site.

The first problem I encountered is that the wadl2java documentation describes very good how to use the generator but doesn't speak of using the generated code. Thus while the generation went smoothly, using the generated code meant reading the generated source code to figure out what each function does and how to use it. And I thought that generating a client would make my life simpeler!

As I see this blog as a way to share stuff I learned so that hopefully someone who needs the same information can google this up, I'll try to explain who I think it has to be used. A single class EndPoint is generated containing a lot of inner classes. Using the inner classes, you can build the URL you would like to access.
/resource becomes new EndPoint.Resource()
/resource/contract becomes new EndPoint.Resource.Contract()
/resource/{id} becomes new EndPoint.Resource.Id(id)
/resource/{id}/contract becomes EndPoint.Resource.IdContract(id)

The inner classes have methods combining the HTTP method and representation. Some examples should clarify this.
getAsHtml() does a HTTP GET to retrieve a HTML representation
getAsJson() does a HTTP GET to retrieve a JSON representation
put() performs a HTTP PUT with as input a DataSource

What you get back (or need to send in case of a PUT/POST) is of type DataSource. Some things you can do with this DataSource object:

Retrieve a representation out of it:
dataSource.getInputStream()
Put an XML representation in it:
String updatedPerson = "";
input = new ByteArrayDataSource(updatedPerson.getBytes(), "application/xml");

This should help you use the generated classes. If you find some easier methods, don't hesitate to comment further.

I like the wadl2java generation as fast client builder but I think it has a lot of shortcomings to provide a powerful interface to a REST service. It should also make it easier to use more advanced features as caching, conditional GET, error handling and such. I know understand the concerns of others that when using WADL you dumb down REST and hide the advanced features. It has the same problems as giving WSDL client generation to the developer masses so that they aren't aware of how powerful SOAP and WS-* can be.

Know why ...

2009-05-08T16:14:00.002+02:00

When doing things as they have always been done, it is important to sometimes say 'STOP!' and try to figure out why you should do it like that. If encountered this a couple of times this week.

When adding a comment on an overridden method, eclipse automagically enters {@inheritDoc} and that's it. Made sense to me but I had no idea what the things does. Well in this case, the {@inheritDoc} and what the default behavior is when there is no comment is the same. Thus for keeping you're code clean instead of cluttering it with unuseful stuff, you could just ommit it. You can still use it if you want to add to the original comment because {@inheritDoc} will copy over the original comment at that place. Something like this:

/**
* {@inheritDoc} and does a lot of other useful stuff.
*/
public void overriddenMethod()

Generating getters and setters for domain objects was the second thing I do most of the time. It seems like a good idea and makes all information easily accessible. On the other hand it makes things so simple that you don't think about encapsulation anymore and do things in the wrong place. A better approach is to wait to create the getters and setters until you really need them and at that time think how you could still keep the data encapsulated.

Internationalization for javascript on top of a Java web application

2009-01-12T13:12:00.004+01:00

In a Java web application, the i18n is usually handled by using resource bundles. When using javascript, you could use something resource bundle alike like dojo suggests but then you need to make the properties files available to the browser and for every page, all translations are loaded. I would rather like to keep using the resource bundles that I know and have tools to edit for in both my jsp's and javascript.

For this end, I have written a small tag that reads the translations you need and puts them in a small JSON object. The tag currently looks like this (I only use it in one application thus customization is not yet an issue):


public class ResourceToJavaScriptTag extends TagSupport {
 /**
  * Only the keys starting with this filter will be added to the bundle.
  * Also this starting part of the key will be removed (making JSON attributes easier to access).
  */
 private String filter = "";
 /**
  * The name of the bundle.
  */
 private String name = "";

 @Override
 public int doStartTag() throws JspException {
     try {
         StringBuilder bundle = new StringBuilder();
         bundle.append("");
         pageContext.getOut().print(bundle);
     } catch (Exception ex) {
        throw new JspTagException("ResourceToJavaScriptTag: " +
           ex.getMessage());
     }
     return SKIP_BODY;
  }

 @Override
  public int doEndTag() {
     return EVAL_PAGE;
  }

  public void setFilter(String filter){
      this.filter = filter;
  }

  public String getFilter(){
      return filter;
  }

 public String getName() {
     return name;
 }

 public void setName(String name) {
     this.name = name;
 }
}

The filter is determines which translations to select. Only the keys starting with this filter will be added to the object. The name is the name of the javascript object containing the translations.
The tag <tags:i18n filter="my.translations" name="myBundle"> gives me:
<script type="text/javascript">var myBundle = {"trans1":"my translation1","trans2":"my translation2"}</script>
for the properties
my.translations.trans1=my translation1
my.translations.trans2=my translation2
your.translations.trans3=your translation3

As you can see, only the keys starting with my.translations are added to the json object. Now we can get a translation as myBundle.trans1.

Derby database using hibernate in JavaSE

2008-12-31T11:24:00.004+01:00

I found only bits and pieces about how to configure persistence for a standalone application (or a junit test as what I needed) using a simple database (Derby is delivered with JavaSE 6).

You will need the following jars:

derby.jar : delivered with javaSE 6 in the db folder or downloaded here. Another good candidate would be hsqldb that can also be used in memory (this will need a different connection-url).
hibernate-entitymanager.jar and all the jars it needs.

The persistence.xml that needs to be placed in the META-INF folder should look like this:

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.0"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
              http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
<persistence-unit name="HibernateApp">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<properties>
 <property name="hibernate.archive.autodetection" value="class" />
 <property name="hibernate.format_sql" value="true" />
 <property name="hibernate.show_sql" value="true" />
 <property name="hibernate.hbm2ddl.auto" value="create-drop" />
 <property name="hibernate.connection.url" value="jdbc:derby:target/database/jpa-test-database;create=true" />
 <property name="hibernate.connection.driver_class" value="org.apache.derby.jdbc.EmbeddedDriver" />
 <property name="hibernate.dialect" value="org.hibernate.dialect.DerbyDialect" />
 <property name="hibernate.connection.username" value="user" />
 <property name="hibernate.connection.password" value="password" />
</properties>
</persistence-unit>
</persistence>

The entity manager can then be retrieved as follows:

EntityManagerFactory emf = Persistence.createEntityManagerFactory("HibernateApp");
EntityManager entityManagerToUse = emf.createEntityManager();

If anyone has a good hsqldb example, it would be a nice addition to this post.

URI Design for REST

2008-12-17T13:34:00.017+01:00

Introduction

After making the example to fit a restful design in struts 1.x, I began investigating which rules exist to create a URI. A URI should be a simple representation but as I we all know, making things simple is the hardest thing to do.
I found some blogposts talking about this topic:

It started with Dave Thomas,
then Robert Hahn responded to it and
Pat Maddox didn't fully agree.

The initial take is how Ruby handles the URI design because there seems to be discussion about using GET /resource/1;edit or GET /resource/1/edit.
I also think there are more cases that need to be handled, for example

doing a search for a resource,
performing a calculation,
showing partial information of a resource,
showing an aggregated view of multiple resources,
...

Also, a URI should always be accompanied with its http method to know what the function is (the function should be a sentence where the http method is the verb and the URI the direct object an example would be "I get resource 1").
In this blog post I won't take in account that a normal browser request can't change the Accept header and can't send any thing else than GET and POST. These shortcomings will need to be emulated in some way.

Identified resources

GET /resource/1 : Showing a single resource with identifier 1. We could also do GET /resources/1 which would be more of a search but since it only returns one item I agree with Robert Hahn that the first representation is the best.Using the different http methods we get:

POST /resource/1 : Add a resource and use identifier 1 (in a lot of cases, this will make no sense since the identifier will be created by the server or database)
PUT /resource/1 : Update the resource with identifier 1
DELETE /resource/1 : Delete the resource with identifier 1

Now we get to the difficult one. How do we get to the page where we will update the attributes of the resource. The links I provided above give the following solutions for this: GET /resource/1;edit (apparently from Ruby), GET /resource/editable/1 and GET /resource/1.form. All of these just don't seem to feel right. I think the editable representation is just a representation as another and should be handled as such. Thus giving an Accept header as text/form.

A newly created resource

GET /resource : Get the input form to create a new resource
POST /resource : Create a new resource. The result should be a redirect to GET /resource/new_id

Put and delete do not make sense for resources that do not yet exist, thus an identifier should be given in that case.

Searching a resource

GET /resource?field=searchvalue&field2=searchvalue2 : Searching is why request parameters exist so use them for this. A very complex search could be handled in the same way as a calculation.

Multiple representations of the same resource

Multiple representations should be retrieved using a different Accept header. Problem is that in the browser, the request header can only be set when doing an AJAX request. For links, you are stuck with what the browser provides.

Aggregated view of multiple resources

I think this is just a different view (=Accept Header) for a resource. Thus information of a person with his address would be GET /person/1/address with an Accept header text/vnd.app.person+address.
What if you want to see or edit a person with his address and orders on one screen? I assume something of the following: GET /person/1/address+orders would do. The address and the orders are related to the person and not to each other thus GET /person/1/address/orders would be wrong.

Calculation

Calculations are a two step process. This first is creation of the calculation, the second retrieval of the result. Thus a POST /calculation would be redirected to return a GET /calculation/123 . If this calculation is long running, the GET could be polled to check if the result is already available. The nice thing of this is that you could bookmark the result or send it to someone else without redoing the calculation.
This solution also has its impact on the server side. The result of the calculation will need to be stored somewhere or a 410 Gone should be returned (this could also be a 404 if there was no result with the given id but how are you going to know this?)

Other REST issues to think about

Governance of URI's: As for SOAP web services, REST web services should be reusable. A certain amount of governance is needed to achieve this across projects. I found the following nice article on infoq. It doesn't give any satisfying solution but still a nice read.
How to get links in your response in an easy manner?
Maybe I should see REST less as "returning a presentation" and more as "providing a service". It needs a smart client to talk to services, a dumb client (=browser) can only show a representation. In this, I follow the article of Dave Thomas.
Circumvent the problem that in a browser could can't set the Accept header (or any other header) in the request. Same for PUT and DELETE, this is supported by google with a hidden field in a POST request that is on the serverside translated.
Add your own ...

Conclusion

URI design is not that easy. Once you make a decision on how each function is represented by a URI, you should stick with that style for your entire site. Having a clear set of guidelines to create URI's is more important than selecting THE BEST style.

Restful design with Struts 1.x

2008-12-16T15:09:00.015+01:00

I did some more research when following up a previous blogpost. Apparently there is no real guide to use REST with struts 1.x. There exists REST plugin for struts 2.x. This makes sense since Struts 1.x is considered to be end of life.
When trying to fit a restful design in the old struts, I came to the following class. A lot of pieces should be generalized in a helper class or in a common superclass (maybe RestAction ?).

public ActionForward execute(ActionMapping mapping, ActionForm form,
         HttpServletRequest request, HttpServletResponse response)
         throws Exception {

     if (request.getMethod().equals("GET")){
         String extraPath = request.getPathInfo();
         String[] groups = extraPath.split("/");
         if (groups.length == 3){
             // URI /resource/{id}
             request.setAttribute("id", groups[2]);

             String acceptHeader = request.getHeader("Accept");
             System.out.println("Accept: " + acceptHeader);
             int htmlIndex = acceptHeader.indexOf("text/html");
             int xmlIndex = acceptHeader.indexOf("application/xml");
             System.out.println("Indexes " + htmlIndex + "*" + xmlIndex);
             if (htmlIndex >= 0){
                if (htmlIndex < xmlIndex){
                    return mapping.findForward("resourceHTML");
                }else{
                    return mapping.findForward("resourceXML");
                }
             }
             if (xmlIndex >= 0){
                 return mapping.findForward("resourceXML");
             }
         }else if (groups.length == 2){
             // URI : /resource
             return mapping.findForward("newResourceHTML");
         }
     }else if (request.getMethod().equals("POST")){
         // Create a new resource element and redirect to the view
         response.sendRedirect("/restStruts/rest/resource/NEW_ID");
         return null;
     }
     response.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);
     return null;
 }

And the struts-config.xml looks like:

<struts-config>
<form-beans>
    <form-bean name="resourceForm" type="be.struts.rest.ResourceForm">
</form-bean>
<action-mappings>
    <action path="/resource**" type="be.struts.rest.ResourceAction" name="resourceForm" scope="request">
        <forward name="resourceXML" path="/pages/resourceXML.jsp">
        <forward name="resourceHTML" path="/pages/resourceHTML.jsp">
        <forward name="newResourceHTML" path="/pages/newResourceHTML.jsp">
    </forward>
</forward>
</forward></action></action-mappings>
</form-beans>
</struts-config>

Now let us look how good this adheres to a restful design:

1. Have nice URI's with good ids
The path for the action is "/resource**" what means everything what starts with /resource is passed to that action. The rest of the URI has to be parsed as shown in the ResourceAction class. The following URI's are supported in this action:

/resource : Shows a form to create a new resource or creates a new resource depending on the HTTP method.
/resource/{id} : Shows the resource with given id.

Supporting other URI's that start with /resource could easily be resolved by parsing the pathInfo in the request. This would be a good candidate for generalization.

2. Use the HTTP methods
Depending on GET or POST on the /resource path, an input screen is shown or a new resource is created (with a redirect to the representation of that resource).

3. Use the ACCEPT header
Reading the headers of a request is provided by struts. Depending on the value of the ACCEPT header, a HTML representation or a XML representation. To test retrieving the XML representation I've written a small application. (I did not find a way to change the Accept header used by the browser using HTML or javascript. It can be done through about:config in firefox by changing the network.http.accept.default key)

public static void main(String[] args) throws Exception {
        URL url = new URL("http://localhost:8080/restStruts/rest/resource");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.addRequestProperty("Accept", "application/xml");
        InputStream content = (InputStream) conn.getContent();
        BufferedReader postBufferedReader = new BufferedReader(new InputStreamReader(content));
        String postline = null;
        while((postline = postBufferedReader.readLine()) != null) {
            System.out.println(postline);
        }
    }

Any suggestions to do this in the browser are appreciated.
4. Use HTTP response codes
Sending an HTTP response code in struts is quite easy. Just set the error code in the reponse object:

response.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);
return null;

5. Use links in the response
Since the response is a JSP, putting links in there is as you wish. A URIBuilder like in Jersey would be nice though.

6. Stateless communication
Again this is a best practice that you should try to implement. Put all the forms in the request scope would be a good step. There is nothing is struts 1.x that keeps you from doing stateless communication.

7. Use ETag
The same way as the Accept header is read, the ETag header can be read. It should also be added to the response. I would use a form like ID-LAST_MODIFICATION_DATE and then check if the resource with given id was updated after the given modifcation date. If not, the right response code can be returned.

Devoxx lessons learned

2008-12-16T08:38:00.004+01:00

As I look look back to devoxx, I see three important trends:

REST: The session about Restful design showed that using HTTP correctly makes live simple. Instead of needing to know basic HTTP and a whole bunch of stuff above it, try to use the basic tool to its fullest. Other sessions like JAX-RS and Spring 3.0 made it clear that it is now possible to really achieve a restful design.
WebSockets: HTML5 is only scheduled for 2022 but using the kaazing.org emulation, you can already use it now cross-browser. Some browsers are already implementing parts but the rest of the needed stack is emulated. The promise of having a TCP socket in your browser opens a lot of possibilities.
Developer productivity: Agile becomes a de facto standard but without the right tools and without using them in the right way, the productivity of a regular developer is still too low. For example, using Glassfish V3 (fast startup due to modular design) and javarebel (replace classes without redeploy) the development cycle is shortened considerably.

I didn't follow too much of the other hot stuff like RIA and scripting. They are interesting but getting approval to use them in a corporate environment is hard.

Restful design and struts 1.X

2008-12-11T11:57:00.003+01:00

Yesterday, I followed the session about restful design of Stefan Tilkov. You can find his articles here. Using the web as it should be used with good URI's and GET/POST/PUT/DELETE methods seems very natural. The anti-patterns and patterns made it more clear what was meant with that.

I just want to figure out how to apply this when the company forces you to use struts 1.X. Apparently somebody else already tried to find this out. I have to try this!

Devoxx keynote JavaFX

2008-12-10T12:01:00.001+01:00

JavaFX, the next cool rich internet application, has come out last week so it wasn't a surprise that the keynote was about that. I already played with the preview before and what I saw that they provide for the designers, I think it will be a real contender for flex and silverlight.

The only thing that Sun still needs to make this a succes, is a motivated and inspiring speaker. Choosing you chief software architect to present it may not be a good idea ...

HTML5 websockets

2008-12-09T13:05:00.002+01:00

The session about WebSockets (misnamed as being about Comet) was interesting to see where all the new web standards are going. The people of Kaazing are emulating them since not much is implemented yet. As they get implemented, they will be used.
WebSockets give a tcp socket to the browser client allowing all kinds of communication to many types of servers. Sounds promising and thanks to the emulation it is here now instead of 2022 (releasedate HTML5).

Developer productivity

2008-12-09T12:57:00.002+01:00

Yesterday I followed the session "10 reasons why JavaEE development doesn't have to be painful". This Sun sponsored session talked a lot about how tools and fast appservers enhance developer productivity. This is the same as "Keep the developer in his stream of thoughts". A constant interruption of this thought stream because of restarts or waiting for the IDE to respond, is

disastrous for productivity.

I talked at the javarebel stand about this talk and there take was, what good is a fast starting appserver is deployment still takes long. By avoiding need to redeploy, they can make it still faster.

It's more a message to managers. If you want your developers to be productive, give them good tools on fast machines.

Servlet 3.0/JSF 2.0

2008-12-08T16:49:00.002+01:00

Servlet 3.0 doesn't add that much (unless a lot was not told about in the session). The most mportant is making the web.xml easier to handle by having modularization (merging multiple web.xml's from different libraries), annotations and being able to add artifacts programmatically during deployment.
The only other big addition is asynchronous requests. This makes it possible to have less thread usage when doing a long call (e.g. database call) or an asynchronous call (e.g. JMS message exchange). Another use case is keeping a connection open.

JSF2 has a lot of changes with built-in facelets and AJAX, better exception handling, resource handling and state saving. Less XML is possible by using annotations and they still think about adding REST support. The conversation scope was moved to the webbeans proposal.

My feeling is that JSF is way too complicated but maybe that is because of my lack of experience on it.

Cancelled sessions

2008-12-08T11:39:00.005+01:00

The two session is was going to follow were cancelled. The first "From XML to Java and back again" was replaced by a more general JPA session and a short bit about eclipse tooling for it (more specifically hibernate tooling but the DALI part was also interesting to see).

I still picked up some things of the more general JPA session that was given by Alex Snaps who I know of the project I'm currently working on.

Understand the ORM tool you are using. This is a valuable lesson because otherwise you'll end up with strange behavior you don't understand. For example, that you have to maintain your bidirectional mapping yourself or more hibernate specific, that a filter is allowing you to only get back results from one specific database partition (happened to me and costed me a long debugging session). Another one is that bulk operations do not update the entity manager.
The @MapKey annotation I did not remember but seems useful if you want to find back a relationship using a specific key. I'm just wondering how this works when there is more than one object for a key. Can you use a Map object to put them in then? Apparently currently you can't. Maybe JPA2?
Usage of @Version for optomistic locking.
Listeners for validation (pre), setting calculated values (post) or auditing (post). What other usage scenarios are possible?

The EM goes to the database if the transaction ends or when you flush inside a transaction. Thus when you make changes outside a transaction but with an open persistence context (still managed entities instead of detached entities), you have to open and close a connection to have these updates reflected in the database. If you close the persistence context, all updates after
the last transaction end will be lost when the entity becomes detached. (You will have to merge the enities to still save the changes)

The tools seem very useful providing validation, code completion en with hibernate tooling also query validation and testing. Also the integration with eclipse DTP is well done.

Devoxx next week

2008-12-05T13:08:00.004+01:00

I'm going to devoxx next week and I hope to kickstart this blog with all the interesting things I'll see there. It'll be my fourth visit in a row to what was JavaPolis but is now Devoxx. That's the advantage of actually living in Belgium.

I still remember the first visit when it was a new world going open for me. I saw and learned a lot of new things back then. A whole difference with last year when I saw a lot of the same things of the year before. Hopefully this year will be different again.