It’s a very plain example based on the Google Maps v3 and a bit of jQuery but that can easily be avoided.

First the necessary html:

<script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=true"></script>
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.6.1/jquery.min.js" type="text/javascript"></script>

<style>
  #map_canvas {
    height:500px;
    width:600px;
 }
 #directions {
   width:600px;
 }
</style>

<div id="map_canvas"></div>
<h2>Plan your trip</h2>
<form id="routeform">
  City or zipcode:
  <input type="text" name="routefrom" id="routefrom"/>
  <input type="submit" value="calculate"/>
</form>
<div id="directions"></div>

And the Javascript:

$(document).ready(function()
{
  initialize();

  $('#routeform').submit(function(e)
  {
    calcRoute();
    return false;
  });

});

var directionDisplay;
var directionsService = new google.maps.DirectionsService();
var map;
var home = new google.maps.LatLng(52.0951, 5.109);

function initialize()
{
  directionsDisplay = new google.maps.DirectionsRenderer();

  var myOptions =
  {
    zoom:8,
    mapTypeId: google.maps.MapTypeId.ROADMAP,
    center: home
  }
  map = new google.maps.Map(document.getElementById("map_canvas"), myOptions);
  directionsDisplay.setMap(map);
  directionsDisplay.setPanel(document.getElementById("directions"));

  var myLatLng = new google.maps.LatLng(52.0951, 5.109);
  var beachMarker = new google.maps.Marker
  ({
      position: myLatLng,
      map: map
  });
}

function calcRoute()
{
  var start = document.getElementById("routefrom").value;

  var request =
  {
    origin:start,
    destination:home,
    travelMode: google.maps.DirectionsTravelMode.DRIVING
  };
  directionsService.route(request, function(response, status)
  {
    if (status == google.maps.DirectionsStatus.OK)
    {
      directionsDisplay.setDirections(response);
    }
  });
}

Which results in:

Plan your trip

Two weeks ago I was working on a connection with a common webservice which authentication was based on plain http basic authentication. I used CXF as a client library to handle the plumbing for me, the basic code looked like this:

JaxWsProxyFactoryBean clientFactory = new JaxWsProxyFactoryBean();
clientFactory.setAddress("http://webservice.url.com");
clientFactory.setServiceClass(MyLocalInterface.class);
clientFactory.setUsername("rob");
clientFactory.setPassword("secret");
fundaSoap = clientFactory.create(MyLocalInterface.class);

From the start this worked great and simple, till the moment that I set up another connection based on the same url but other credentials…… That’s where the problem began. Connection nr 2 was now messed up with the credentials of connection nr 1 and as I never heard of this behavior, I refused to believe it either. But after diving into server logs, I couldn’t deny it anymore. My client code was screwed up. After some googling I found the problem, the JDK is caching credentials based on the url and port of your http request. And resetting that cache by calling the Authenticator class doesn’t help you due to this bug:

http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6626700

So there’s just one way to avoid this bug and that’s fooling the JDK that you’ve used the credentials before:

AuthCacheValue.setAuthCache(new AuthCache()
{
  @Override
  public void remove(String arg0, AuthCacheValue arg1) { }

  @Override
  public void put(String arg0, AuthCacheValue arg1) { }

  @Override
  public AuthCacheValue get(String arg0, String arg1)
  {
    return null;
  }
});

I hope my post will help other people with the same kind of issues as this took me some time to figure out what was happening and I don’t want that somebody else spoils his or her time on this.

Apart from this post, I’m really happy with the CXF library (based on the old XFire project) and I’ll try to publish more on that later.

After three years of having the good intention, I finally motivated myself to take the SCJP exam. From the moment I started working after my study, I told myself many times that I should for some Java certification. Just to prove that I understand what I’m doing. So I started reading in the SCJP 5 study guide (the Sierra and Bates book), and started several times…..

A lot of information was pretty interesting but on the other hand I couldn’t really motivate myself to learn on exotic facts which I never use in practice. Due that fact, I quit learning on SCJP5. Last year I finally picked it up again by buying the Java 6 version of the Sierra and Bates book. Again fighting with the same contradicting facts of useful and useless knowledge but now determined to finish it!

I’ll give a short summary of how I studied. Started with reading the book and making notes for every chapter. After each chapter, I made the test questions and reviewed them. I added the best practices to the notes and learned from my mistakes which were for 50% just silly and stupid ones. After finishing the book, I never opened it again. From that moment I started practicing by just writing several small test applications to get a feeling with several subjects. And doing different mock tests. I would like to mention and recommend the examlab software from Devaka Cooray, it’s free and is really approaching the real exam.

So that’s it for now. I’m currently working on bookmarkeable ajax urls and back button support for ajax urls in php based on CodeIgniter and JQuery. I’ll definitely post my solution here once it’s a bit finished. And not unimportant, I’m about to leave for a trip to India (for work), maybe I’ll write something about that as well.

Oh but now the most important, the result of my exam:

PASSED with a 85% score!!!

What’s next:

• Training and collecting for our goal this year
• Then thinking about another certification
• Drinking a beer to celebrate my score

Tips:

• Be very secure!! Most of my mistakes were not noticing minor, non-head braking things.
• Read a good book, make notes, re-read those notes several times
• Practice as much as you can on mock tests (for example examlab.tk)
• Visit the Javaranch SCJP forum, contains a lot of useful information
• Have fun!

The solution contains two parts, a custom FeedbackPanel and an implementation of the IFeedbackMessageFilter.

Custom FeedbackPanel:

private class UniqueMessagesFeedbackPanel extends FeedbackPanel
  {
    private UniqueMessageFilter filter = new UniqueMessageFilter();

    @Override
    protected void onBeforeRender()
    {
      super.onBeforeRender();
      // clear old messages
      filter.clearMessages();
    }

    public UniqueMessagesFeedbackPanel(String id)
    {
      super(id);
      setFilter(filter);
    }
  }

And the filter class:

public class UniqueMessageFilter implements IFeedbackMessageFilter
  {
    List<FeedbackMessage> messages = new ArrayList<FeedbackMessage>();

    public void clearMessages()
    {
      messages.clear();
    }

    @Override
    public boolean accept(FeedbackMessage currentMessage)
    {
      // too bad that FeedbackMessage doesnt have an equals implementation
      for(FeedbackMessage message: messages)
        if(message.getMessage().toString().equals(currentMessage.getMessage().toString()))
          return false;
      messages.add(currentMessage);
      return true;
    }
  }

I'm looking for a a more beautiful way to cleanup the messages but it seems impossible since the FeedbackMessage class does not implement an own equals version. And if it was implemented, it propably checks on too much properties, like the component which throws the message and that still results in duplicate messages. ]]> http://tigrou.nl/2010/02/06/filtering-your-duplicate-feedbackmessages-in-wicket/feed/ 1 http://tigrou.nl/2010/01/02/context-based-urls-with-apache-wicket/ http://tigrou.nl/2010/01/02/context-based-urls-with-apache-wicket/#comments Sat, 02 Jan 2010 15:47:07 +0000 Rob http://tigrou.nl/?p=225 It’s been a while that I wrote something technical on my blog. The last ones were mainly about biking which is taking a lot of my spare time these days. I haven’t blogged about Wicket before but that doesn’t mean that I use it a lot. For the last 2 years, I’m using it at my work at Maxxton for developing rich content websites. In one of the usecases a month ago, we needed something for storing parameters in the urls which would never get lost after clicking around. After a little googling on the web, I found an example on the Wicket wiki which allowed you to add the locale in the url. I’ve re-used that example and made it a bit more generic by allowing key-value pairs instead of one hardcoded string.

The used keys are defined by a simple enum:

private enum Param {
LANGUAGE("lan"), THEME("theme");

private final String value;

Param(String value) {
this.value = value;
}

public String getValue() {
return value;
}
};

In this example I used two different params which can be used in combination with eachother or separated. I won’t add all the Java code in long listings over here because of the amount of code but you can download my Eclipse project at the end of this blogpost.

There are actually two important spots, a custom RequestCodingStrategy and the registration of that class in the WebApplication. But before I show that code, let’s give some examples of the urls which will be created/working:

• http://localhost:8080/urlexample/theme/red/lan/nl/home
• http://localhost:8080/urlexample/lan/nl/home
• http://localhost:8080/urlexample/theme/red/home
• http://localhost:8080/urlexample/home

All of these urls are pointing to the homepage mounted at “home”. The bold parts are the key-value pairs which are read in our RequestCodingStrategy and stored in the session for later use. The beauty of this solution is that every generated url, will still contain these values. So in my example, I created a link to another page called “end” and that url will be something like http://localhost:8080/urlexample/theme/red/lan/nl/end.

So how does that look like, lets start with the 2 overridden methods in my WebApplication:

@Override
protected IRequestCycleProcessor newRequestCycleProcessor() {
return new WebRequestCycleProcessor() {
@Override
protected IRequestCodingStrategy newRequestCodingStrategy() {
return new ParamUrlCodingStrategy(super
.newRequestCodingStrategy());
}
};
}

@Override
public Session newSession(Request request, Response response) {
return new CustomSession(request);
}

The newRequestCycleProcessor() returns the custom RequestCodingStrategy instead of the default one. and the newSession() returns our custom session for storing the values. Nothing special.

Lets take a look now to our custom RequestCodingStrategy where most of the magics happens. I only show a stripped version of the one in the example project:

public class ParamUrlCodingStrategy extends RequestCodingStrategy {

public ParamUrlCodingStrategy(final IRequestCodingStrategy defaultStrategy) {
super(defaultStrategy);
}

@Override
public RequestParameters decode(final Request request) {
final String requestLanguage = getParamValue(request.getPath(),
Param.LANGUAGE);
final String requestTheme = getParamValue(request.getPath(),
Param.THEME);

// for example, use a custom session object to store your values
if (requestLanguage != null) {
((CustomSession) Session.get()).setLanguage(requestLanguage);
}
if (requestTheme != null) {
((CustomSession) Session.get()).setTheme(requestTheme);
}

String url = request.decodeURL(request.getURL());

// remove params from request
for (Param param : Param.values()) {
url = stripParamFromPath(url, param);
}
final String urlWithoutParams = url;

// use decorator for decoding
return getDecoratedStrategy().decode(new RequestDecorator(request) {
@Override
public String getURL() {
return urlWithoutParams;
}

@Override
public String getPath() {
return urlWithoutParams;
}
});
}

@Override
public CharSequence encode(final RequestCycle requestCycle,
final IRequestTarget requestTarget) {
String url = getDecoratedStrategy().encode(requestCycle, requestTarget)
.toString();

// rewrite only requests for pages & links
if (requestTarget instanceof IBookmarkablePageRequestTarget
|| requestTarget instanceof IPageRequestTarget) {

String theme = ((CustomSession) Session.get()).getTheme();
String language = ((CustomSession) Session.get()).getLanguage();

// language
if (language != null && !language.isEmpty()) {
if (url.startsWith("../")) {
final int lastIndex = url.lastIndexOf("../") + 3;
final String remainingUrl = url.substring(lastIndex);
if (!remainingUrl.isEmpty()) {
url = url.substring(0, lastIndex)
+ Param.LANGUAGE.getValue() + "/" + language
+ "/" + remainingUrl;
}
}
// if starts with . -> skip
else if (!url.startsWith(".")) {
url = Param.LANGUAGE.getValue() + "/" + language + "/"
+ url;
}
}
// and theme
if (theme != null && !theme.isEmpty()) {
if (url.startsWith("../")) {
final int lastIndex = url.lastIndexOf("../") + 3;
final String remainingUrl = url.substring(lastIndex);
if (!remainingUrl.isEmpty()) {
url = url.substring(0, lastIndex)
+ Param.THEME.getValue() + "/" + theme + "/"
+ remainingUrl;
}
}
// if starts with . -> skip
else if (!url.startsWith(".")) {
url = Param.THEME.getValue() + "/" + theme + "/" + url;
}
}
return url;
}
return url;
}

private String getParamValue(final String path, Param param) {
int index = path.indexOf(param.getValue());
if (index >= 0) {
int indexOfNextSlash = path.indexOf("/", index
+ param.getValue().length() + 1);
String paramValue = path.substring(index
+ param.getValue().length() + 1, indexOfNextSlash);
return paramValue;
}
return null;
}

private String stripParamFromPath(final String path, Param param) {
String paramValue = getParamValue(path, param);

return path.replace(param.getValue() + "/" + paramValue + "/", "");
}

@Override
public IRequestTarget targetForRequest(
final RequestParameters requestParameters) {
// delegate call to decorated codingStrategy, but with params removed
String newPath = requestParameters.getPath();
for (Param param : Param.values()) {
newPath = stripParamFromPath(newPath, param);
}

requestParameters.setPath(newPath);
return super.targetForRequest(requestParameters);
}

@Override
public IRequestTargetUrlCodingStrategy urlCodingStrategyForPath(
final String path) {
String newPath = path;
for (Param param : Param.values()) {
newPath = stripParamFromPath(newPath, param);
}

if (newPath != null && !newPath.isEmpty()) {
// treat this kind of situation by returning some not null
// codingStrategy,
// to let this kind of request treated by wicket
return new PassThroughUrlCodingStrategy(newPath);
}
return super.urlCodingStrategyForPath(newPath);
}

}

As you can see, the encode() and decode() methods do most of the processing. It’s actually nothing more then adding and removing/reading the parameters. The reason that I liked it, is that it’s always executed, no matter what code is used inside the pages. That’s a secure way of adding parameters and not loosing them and as a little dessert, Google likes them as well! Urls are indexed including state in Google which allows you to create language based urls for example.

So that’s it for now. The post only shows the keyfactors of my example. If you’re more interested, you should download my example project and dive into the code.

Download my example Eclipse project

• Keynote – Enterprise 2.0: New Technologies, Innovations and Communities (Reginald Hutcherson)
• Speed up your applications with Java SE 7 (Jeroen Borgers)
• Scaling Out with Hadoop and NoSql (Age Mooij)
• Keynote – Adobe Systems (Christophe Coenraets)
• The Quest for Parallelism: How To ‘upgrade’ Your Application (Jan-Hendrik Kuperus)
• JDK 7, What’s in it and what’s not (Simon Ritter)
• Google Wave: what is it, and how does it work? (Jos Dirksen)

(I translated some of the subjects to English)

Three of them had a lot in common, the speeding up, the parallelism and the jdk7 where the most interesting ones. The other sessions where more informative and for fun.

The subjects I was really excited about, are the new concurrency features in Java. Being this more and more important with the current multicore cpus and the cloud computing hype we can’t ignore it! And it’s not only faster, it’s also very cool and not even hard to give it a try as a normal programmer. I even think that this new stuff makes our live easier then the old fashioned threading stuff in Java 5 and earlier (a lot of new stuff in Java 7 is already available through Java 6 in the updates but often not enabled by default).

Some cool and nice features are:

• Fork join framework (next step in parallelism, helps you execute task based procedures)
• Escape analysis (improvement in allocating memory for objects based on the scope of the object)
• Project jigsaw (module management)
• Compressed 64 bit pointers (store 64 bit pointers in 32 bit)
• Garbage first collector (new algorithm for garbage collecting)

That’s it for now, I didn’t have the time to start playing around with the new Beta of jdk7. Hope to get started soon!

That biking crazyness has now been changed into a new adventure called Duchenne Heroes. In short some facts:

• 7 days of mountainbiking
• 100 km each day
• 10.000 altimeters
• 4 countries
• 4 people per team

And that all with just one main goal, collecting money for the Duchenne foundation. A good description can be read on wikipedia about what Duchenne is. The idea came up after a few beers (always the guilty one ) with some friends and since last saturday, our team of four people is a fact! We started creating a website this week but there’s  a lot of work left: clubjegoes.nl

So, keep an eye on our website if you’re interested or even better, donate money to our team. We need 10.000 euro in total. We’re now busy thinking about how to create special sponsor packages. And not unimportant, start training since this is one of the toughest tours in the Benelux.

My next will soon be published, it’s about the Dutch NLJUG day called JFall which I attended last wednesday. It’s a conference of the Dutch Java user group. I’ll briefly describe the subjects I followed and try to dig into them later. Especially the new Java 7 improvements have my attention, awesome new stuff designed for multi core processors and cloud computing!

The biggest part of the trick is inside a custom type handler, which is actually a helper class with two important methods, the setParameter and the getResult. setParameter if for mapping parameters before firing the query and the getResult is for processing the result (if you use a custom type as an OUT parameter). For the example I used a Quantity class which has two properties, id and quantity. My Oracle types are a struct (Quantity) and a table of that struct (QuantityList)

The code will show you the rest, because once you know how to deal with this, other cases are quite easy.

package nl.tigrou.test;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

import java.util.List;
import oracle.jdbc.driver.OracleTypes;
import oracle.sql.ARRAY;
import oracle.sql.ArrayDescriptor;
import oracle.sql.STRUCT;
import oracle.sql.StructDescriptor;

import org.springframework.jdbc.support.nativejdbc.C3P0NativeJdbcExtractor;
import org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor;

import com.ibatis.sqlmap.client.extensions.ParameterSetter;
import com.ibatis.sqlmap.client.extensions.ResultGetter;
import com.ibatis.sqlmap.client.extensions.TypeHandlerCallback;
import com.ibatis.sqlmap.engine.type.JdbcTypeRegistry;
import com.mchange.v2.c3p0.impl.NewProxyConnection;

public class QuantityListTypeHandler implements TypeHandlerCallback
{

  private static final String QUANTITY = "QUANTITY";
  private static final String QUANTITYLIST = "QUANTITYLIST";

  static
  {
    JdbcTypeRegistry.setType(QUANTITY, OracleTypes.STRUCT);
    JdbcTypeRegistry.setType(QUANTITYLIST, OracleTypes.ARRAY);
  };  

  public void setParameter(ParameterSetter setter, Object parameter) throws SQLException
  {
    try
    {
      List<Quantity> quantities = (List<Quantity>) parameter;

      Connection conn = setter. getPreparedStatement(). getConnection();
      if(conn instanceof NewProxyConnection)
      conn = new C3P0NativeJdbcExtractorImpl().getNativeConnection(conn);

      StructDescriptor quantityStruct = StructDescriptor.createDescriptor(QUANTITY, conn);
      ArrayDescriptor quantityList = ArrayDescriptor.createDescriptor(QUANTITYLIST, conn);

      STRUCT[] elements = new STRUCT[quantities == null ? 0 : quantities.size()];

      for (int count = 0; count < elements.length; count++)
      {
        Quantity quantity = quantities.get(count);

        elements[count] = new STRUCT(quantityStruct, conn, new Object[] { quantity.getId(), quantity.getQuantity() });
      }

      ARRAY array = new ARRAY(quantityList, conn, elements);

      setter.setArray(array);
    } catch (SQLException sqle)
    {
      throw sqle;
    }
  }

  private class C3P0NativeJdbcExtractorImpl extends C3P0NativeJdbcExtractor
  {
    public Connection getNativeConnection(Connection con) throws SQLException
    {
      return doGetNativeConnection(con);
    }
  }

  public Object getResult(ResultGetter getter) throws SQLException
  {
    ARRAY array = (oracle.sql.ARRAY) getter.getArray();
    ResultSet rs = array.getResultSet();
    List<Quantity> quantities = new ArrayList<Quantity>();
    while (rs != null &amp;amp;amp;&amp;amp;amp; rs.next())
    {
     STRUCT struct = (STRUCT) rs.getObject(2);
     Object[] attribs = struct.getAttributes();
     Quantity quantity = new Quantity();
     quantity.setId(((java.math.BigDecimal) attribs[0]).longValue());
     quantity.setQuantity(((java.math.BigDecimal) attribs[1]).intValue());
     quantities.add(quantity);
    }
    return quantities;
  }

  public Object valueOf(String value)
  {
    if (value == null)
      return new ArrayList<Quantity>();
    return value;
  }
}

And the corresponding query in one of your xml mapping files. The magic is all inside the inline parameter.

SELECT * FROM sometable x
LEFT JOIN TABLE (
  CAST
  (
    #quantities,handler=quantityListTypeHandler,jdbcType=STRUCT,javaType=Quantity# AS QuantityList
  )
) s ON (s.identifier = x.id)

BTW, if you haven’t noticed it yet, iBatis 3 is about to release. Check out the release candidates because they did an awesome job!

Example picture:

The only thing I didnt like, where the maps which you need to actually use the gps. For example, a map for the Netherlands costs you around 130 Euro. But there’s also a free alternative which is even better but you’ll have to do some research and reading. One of the sites which helped me a lot is openmtbmaps.org, this is based on the openstreetmaps which are free maps maintained by you and me (I really like that, just like Open Source Software). Openmtbmaps is more dedicated to mountainbiking, meaning other rendering of the map and extra info like difficulty.

Enough about the gps system and maps, now the results! Two weeks ago I went for a holiday to the Black Forest in the southern part of Germany. I uploaded maps to my edge 705 and included some tracks from gpsies.com (amazing site too). Once there, I also bought an old fashioned paper based map including some routes at the local store.

I have biked several tracks but a nice (and heavy) one I would like to use as an example. It was a track over 60 kilometers and more then a thousand meters of climbing. I’m still experiencing with all the software and converting of thousand standards in maps world (gpx, kml, kmz, tcx etc), so there are some strange details in the charts below. Like the straight lines in google maps and the max speed of 20 km/h in the last chart. Yes, I’m sure that I biked harder . With a max of 55 km/h.

So the experiencing is still not over and my Edge 705 has a lot of unused features. Time to go biking again!

Let’s start with the note in the documentation:

Advising aspects

In Spring AOP, it is not possible to have aspects themselves be the target of advice from other aspects. The @Aspect annotation on a class marks it as an aspect, and hence excludes it from auto-proxying.

(Source – Spring reference docs)

After searching a bit more information, since the text above not really explains why they’re excluded, I found the following 2 “rules”:

• Classes with annotations @AspectJ and classes that implement or extend any other AOP component are excluded from the autoproxy. This is because they aren’t target classes, and they perform tasks in Spring AOP infrastructure.
• Proxy is not applied to beans that implement the interfaces BeanPostProcessor or BeanFactoryPostProcessor. The class AnnotationAwareAspectJAutoProxyCreator implements the interface BeanPostProcessor, which allows the class to modify the life cycle of beans on which a proxy must be created and applied.

The first point here explains why Aspects are not proxied. The second point names another condition.

So, conclusion:

Never use Aspects (@Apects) and proxy based transaction management on the same bean!

It’s simple to avoid by creating a separate Aspect which advices other beans. Something like this:

@Aspect
public class TestAspect
{

  @Before("execution(* someThing) ")
  public void doSomethingElse()
  {

  }
}

That’s it! At the moment I’m working on the website of my local athletics club, with CodeIgniter I’m finally enjoying PHP programming again.