So, I have been coding Java for a long time, but just that subset of Java that lives within the realm of a web application server. I never really had occasion to build anything like an application with its own GUI that lived on the desktop. For one reason or another, that’s just something that had never come up.

Until now.

It may be the same language, but I have to say, it’s an entirely different world. Labels and Frames; Panels and Panes; Listeners and Layouts; TrayIcons and Popups; Bindings and Actions; GridBagLayouts, SplitPanes, Buttons, and Borders.

Timers and Workers and Threads … Oh, My!

We are definitely not in Kansas anymore, Toto!

Offering Bookmarklets with icons

Now, I have to say that his little hack to make all of this magic happen is rather ingenious, and I do like it. I just could not get it to work in my version of Firefox. Everything started out great in the beginning. The first example worked just fine for me. I can take this little icon:

… and add it to this bookmarklet:

Click Me!

…. and the image shows up just as advertised. Drag it up to your browser’s tool bar and see for yourself. It works! But when I started getting into the conditional stuff, the icon would only show up when the HTML side was true, not when the Javascript side was true. In other words, I could have my choice of a working bookmarklet with no icon or a bookmarklet with a nice icon that didn’t do anything! I could never figure out how to get it to recognize the HTML side of the conditional and load the icon, yet execute the Javascript when the bookmarklet was clicked. I could get one to work, or I could get the other to work, but I could never get them both to work at the same time.

Apparently, I’m just not smart enough to figure that out, so I did the next best thing and just gave up trying, and then went with a slightly different approach:

Click Me!

This version uses the window.location.href as it’s conditional, so if you are on the page that hosts the bookmarklet you get the HTML, otherwise you get the Javascript. Now, using this approach, the bookmarklet doesn’t function on the page on which you got it, but when you are on that page, you can load the icon, and once loaded, it’s there for life. Here’s what it looks like under the hood:

<a href="javascript:if(window.location.href.indexOf('http://blog.restafarian.org/')==0)
{'%3C!DOCTYPE%20html%3E%3Chtml%3E%3Chead%3E%3Clink%20rel="icon
"%20type="image/png"%20href="http://blog.restafarian.org
/wp-content/uploads/2010/07/chat.png"/%3E%3C/head%3E%3Cbody%20onload=
"history.back();"%3E%3C/body%3E%3C/html%3E';}else{
alert('Do%20bookmarklet%20stuff%20...');}">Click Me!</a>

There’s probably a better way to do this still, but I did what I could to do what I wanted to do, and that’s going to have to be good enough for now!

Speaking of time (nice segue, no?), I have been having fun with ISO 8601 dates and times for quite a while. On the sever side, I have just been using plain old java.util.Date and java.text.DateFormat. Then I found this:

Joda Time – Java date and time API

According to their home page, “Joda-Time has been created to radically change date and time handling in Java. The JDK classes Date and Calendar are very badly designed, have had numerous bugs and have odd performance effects.”. At this point, I have only played around with DateTime, but I have to say that I like it so far.

One thing that I never did like about DateFormat was that the Time Zone component never rendered out with the colon (“:”) in between the offset hours and offset minutes. I had to add this code:

    String string = FORMAT.format(date);
    return string.substring(0, string.length() - 2) + ":" +
         string.substring(string.length() - 2);

… to this back in the day. With Joda Time, you can accomplish the same thing with this (assuming that “date” is a Joda Time DateTime object):

    String string = date.toString();

It’s one of my new standards!

Second, if you were successfully using the last Spring 3 release candidate in your Maven project, you cannot simply pull up the pom.xml in an editor and change all “.RC3″ to “”. Actually, to be completely accurate, you can do that — you’ll just get a “Build Failed” when you attempt to build your project. The official name of the GA release of Spring 3 is not 3.0.0 — it’s 3.0.0.RELEASE. So … you can do a change all “.RC3″ to “.RELEASE” and that will actually work:

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3 seconds
[INFO] Finished at: Thu Dec 17 07:33:41 PST 2009
[INFO] Final Memory: 4M/26M
[INFO] ------------------------------------------------------------------------

And since the artifacts are now coming from the main Maven repository, you can also remove this from your pom.xml:

<repositories>
 <repository>
  <id>Springframework milestone</id>
  <url>http://maven.springframework.org/milestone</url>
 </repository>
</repositories>

… unless, of course, you are also using the release candidates for Spring Security 3, which does not have a GA version out just yet. In that case, you just shot yourself in the foot by pulling that out prematurely. Not that I know anyone who would do that; I’m just saying …

It’s here just in time for the holidays! Arjen Poutsma has just announced that Spring 3.0.0 is now final and Juergen Hoeller has blogged about the features in the release.

Download | Documentation | Javadoc API | Change Log | JIRA

Congratulations to Juergen, Arjen and all the other SpringSource engineers that worked so hard on the release. Also a huge thank you to all of the dedicated community members that have given feedback and identified issues along the way. Please keep up the good work so that we can continue to make all the Spring projects better and better.

It’s getting closer. Arjen Poutsma has just announced that Spring 3.0.0.RC3 is now available. This release candidate contains lots of fixes to issues raised by community members.

Download | Documentation | Javadoc API | Change Log | JIRA

Thank you to all of the dedicated community members that have given feedback and identified issues. Please keep up the good work so that we can get a high quality 3.0 GA release.

So, another quick “change all” and BAM!:

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 22 seconds
[INFO] Finished at: Fri Dec 04 10:38:33 PST 2009
[INFO] Final Memory: 3M/48M
[INFO] ------------------------------------------------------------------------

Just the way I like it!

Spring 3.0.0.RC2 is (tentatively) scheduled to be released today!

Regards,

Sam

p.s. if you check JIRA now, you’ll notice that there are no more open issues on the RC2 road map.

I did a “change all <version>3.0.0.RC1</version> to <version>3.0.0.RC2</version>” in my pom.xml, but that was a little overzealous, since this announcement does not include Spring Security. So, I had to go back in and reset those back to RC1, after which I was rewarded with my favorite build/install outcome:

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 9 seconds
[INFO] Finished at: Fri Nov 13 10:05:25 PST 2009
[INFO] Final Memory: 3M/52M
[INFO] ------------------------------------------------------------------------

Pretty cool!

Summary: Representational state transfer (REST) was introduced in early 2000 by Roy Fielding’s doctoral dissertation. However, in the Java™ community, it was not standardized until the JSR 311(JAX-RS) specification was finalized in 2008. The first release of its reference implementation is even later. In this article, I introduce Jersey, which is the reference implementation of JSR 311, by describing its essential APIs and annotations. I’ll also show you how you can smoothly transfer from servlet-style services to RESTful services by integrating Jersey into Apache Tomcat.

Basically, I wanted to be able to get to table entries, not as they are defined on the database, but as they are configured in the system. This primarily relates to user-defined properties, which are stored on the database as property01, property02, property03, etc, but which have been given certain characteristics by their creator when the look-up table was defined. Such characteristics include things like name and type and length and source and so on, which is how I wanted to get to things, as opposed to property01, property02, and so forth. That’s why you see this little tidbit of code inside of the service:

  /**
   * <p>Returns the requested table entry.</p>
   *
   * @param tableName the name of the requested table
   * @param entryId the id of the requested entry
   * @return the requested table entry
   */
  private Map<String,Object> buildTableEntry(LookupTable lookupTable, LookupTableEntry lookupTableEntry) {
    Map<String,Object> entry = new TreeMap<String,Object>();

    entry.put("id", lookupTableEntry.getEntryId());
    entry.put("description", lookupTableEntry.getDescription());
    if (lookupTable.getProperties() != null && lookupTable.getProperties().size() > 0) {
      Iterator<LookupTableProperty> i = lookupTable.getProperties().iterator();
      while (i.hasNext()) {
        LookupTableProperty lookupTableProperty = i.next();
        int index = lookupTableProperty.getSequence();
        String name = lookupTableProperty.getName();
        if (StringUtils.isEmpty(lookupTableEntry.getProperty(index))) {
          entry.put(name, "");
        } else {
          entry.put(name, lookupTableEntry.getProperty(index));
        }
      }
    }

    return entry;
  }

The current version just drops the value string into the map at this point, but I have visions of one day using the property’s “type” value to convert the data in to an Integer or Date or whatever object might be appropriate based on the “type” … but I was just too lazy to work all of that out right at the moment.

The service is set up to be configured by Spring, so to make it work, you need to add a little something to your applicationContext.xml file:

<bean id="lookupTableService" class="org.restafarian.core.service.LookupTableService">
  <property name="lookupTableManager" ref="lookupTableManager"/>
  <property name="lookupTableEntryManager" ref="lookupTableEntryManager"/>
  <property name="context" value="${lookup.table.service.context}"/>
</bean>

The service is set up to take advantage of the recent addition of “context” to the Look-up Table framework, so you have to specify which context you want to work with. If you need to access tables from more than one context, say the global context and your application’s specific context, you can simply define an instance of the service for each context required, reusing the same data manager beans for each:

<bean id="globalLookupTableService" class="org.restafarian.core.service.LookupTableService">
  <property name="lookupTableManager" ref="lookupTableManager"/>
  <property name="lookupTableEntryManager" ref="lookupTableEntryManager"/>
  <property name="context" value="global"/>
</bean>

<bean id="applLookupTableService" class="org.restafarian.core.service.LookupTableService">
  <property name="lookupTableManager" ref="lookupTableManager"/>
  <property name="lookupTableEntryManager" ref="lookupTableEntryManager"/>
  <property name="context" value="${my.application.context}"/>
</bean>

Once Spring injects the bean with all of the dependencies and turns it over to your application, then you can just use it to grab tables and table entries as needed:

countryTable = globalLookupTableService.getTable("country");

Now that that is done, I need to get busy putting it to work!

package org.restafarian.core.service;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import org.apache.commons.lang.StringUtils;
import org.restafarian.core.beans.LookupTable;
import org.restafarian.core.beans.LookupTableEntry;
import org.restafarian.core.beans.LookupTableProperty;
import org.restafarian.core.manager.LookupTableEntryManager;
import org.restafarian.core.manager.LookupTableManager;

/**
 * <p>This is the LookupTable service.</p>
 */
public class LookupTableService {
  private String context = null;
  private LookupTableManager lookupTableManager = null;
  private LookupTableEntryManager lookupTableEntryManager = null;

  /**
   * <p>Returns a list of lookup tables in this context.</p>
   *
   * @return a list of lookup tables in this context
   */
  public List<LookupTable> getTables() {
    return lookupTableManager.findByContext(context);
  }

  /**
   * <p>Returns a list of lookup table names in this context.</p>
   *
   * @return a list of lookup table names in this context
   */
  public List<String> getTableNames() {
    List<String> tableNames = new ArrayList<String>();

    List<LookupTable> tableInfo = lookupTableManager.findByContext(context);
    if (tableInfo != null) {
      Iterator<LookupTable> i = tableInfo.iterator();
      while (i.hasNext()) {
        tableNames.add(i.next().getTableName());
      }
    }

    return tableNames;
  }

  /**
   * <p>Returns the definition of the requested lookup table.</p>
   *
   * @param tableName the name of the requested table
   * @return the definition of the requested lookup table
   */
  public LookupTable getTableDefinition(String tableName) {
    return lookupTableManager.findByContextAndTableName(context, tableName);
  }

  /**
   * <p>Returns the contents of the requested lookup table.</p>
   *
   * @param tableName the name of the requested table
   * @return the contents of the requested lookup table
   */
  public Map<String,Map<String,Object>> getTable(String tableName) {
    Map<String,Map<String,Object>> table = null;

    LookupTable lookupTable = lookupTableManager.findByContextAndTableName(context, tableName);
    if (lookupTable != null) {
      table = new TreeMap<String,Map<String,Object>>();
      List<LookupTableEntry> lookupTableEntryList =
           lookupTableEntryManager.findByContextAndTableName(context, tableName);
      if (lookupTableEntryList != null && lookupTableEntryList.size() > 0) {
        Iterator<LookupTableEntry> i = lookupTableEntryList.iterator();
        while (i.hasNext()) {
          LookupTableEntry lookupTableEntry = i.next();
          table.put(lookupTableEntry.getEntryId(), buildTableEntry(lookupTable,
               lookupTableEntry));
        }
      }
    }

    return table;
  }

  /**
   * <p>Returns the requested table entry.</p>
   *
   * @param tableName the name of the requested table
   * @param entryId the id of the requested entry
   * @return the requested table entry
   */
  public Map<String,Object> getTableEntry(String tableName, String entryId) {
    Map<String,Object> entry = null;

    LookupTable lookupTable = lookupTableManager.findByContextAndTableName(context, tableName);
    if (lookupTable != null) {
      LookupTableEntry lookupTableEntry =
           lookupTableEntryManager.findByContextTableEntry(context, tableName, entryId);
      if (lookupTableEntry != null) {
        entry = buildTableEntry(lookupTable, lookupTableEntry);
      }
    }

    return entry;
  }

  /**
   * <p>Returns the requested table entry.</p>
   *
   * @param tableName the name of the requested table
   * @param entryId the id of the requested entry
   * @return the requested table entry
   */
  private Map<String,Object> buildTableEntry(LookupTable lookupTable, LookupTableEntry
         lookupTableEntry) {
    Map<String,Object> entry = new TreeMap<String,Object>();

    entry.put("id", lookupTableEntry.getEntryId());
    entry.put("description", lookupTableEntry.getDescription());
    if (lookupTable.getProperties() != null && lookupTable.getProperties().size() > 0) {
      Iterator<LookupTableProperty> i = lookupTable.getProperties().iterator();
      while (i.hasNext()) {
        LookupTableProperty lookupTableProperty = i.next();
        int index = lookupTableProperty.getSequence();
        String name = lookupTableProperty.getName();
        if (StringUtils.isEmpty(lookupTableEntry.getProperty(index))) {
          entry.put(name, "");
        } else {
          entry.put(name, lookupTableEntry.getProperty(index));
        }
      }
    }

    return entry;
  }

  /**
   * @param context the context to set
   */
  public void setContext(String context) {
    this.context = context;
  }

  /**
   * @param lookupTableManager the lookupTableManager to set
   */
  public void setLookupTableManager(LookupTableManager lookupTableManager) {
    this.lookupTableManager = lookupTableManager;
  }

  /**
   * @param lookupTableEntryManager the lookupTableEntryManager to set
   */
  public void setLookupTableEntryManager(LookupTableEntryManager lookupTableEntryManager) {
    this.lookupTableEntryManager = lookupTableEntryManager;
  }
}

There’s obviously more that could be done here, but for now, it serves its purpose.