Since Google Guice 2.0 we can use Multibinding which allows us to bind multiple objects to a collection.
But the one thing I missed in the current release is the ability to bind objects with a specific annotation. So I thought, why not build it myself

So lets use the Multibinder example written in the Javadoc of Multibinder.

public class SnacksModule extends AbstractModule {
    protected void configure() {
     Multibinder multibinder = Multibinder.newSetBinder(binder(), ISnack.class);
      multibinder.addBinding().toInstance(new Twix());
      multibinder.addBinding().toProvider(SnickersProvider.class);
      multibinder.addBinding().to(Skittles.class);
    }
  }

With this binding, a Set<ISnack> can now be injected:

  class SnackMachine {
    @Inject
    public SnackMachine(Set snacks) { ... }
  }

This is nice if you have a couple of Snacks, but if you have many and you want your
module clean and simple, you probably want something like this

 multibind(ISnack.class).toAnnotatedClasses(Snack.class);

Where a Snack looks like this:

@Snack
public class Snickers implements ISnack { ... }

To make this possible, I created the following Module:

public abstract class AbstractMultibindModule extends AbstractModule {

    public  AdvancedMultibinder multibind(Class clazz) {
        return new AdvancedMultibinder(clazz);
    }

    public class AdvancedMultibinder {
        private Multibinder multibinder;
        private Class clazz;

        private AdvancedMultibinder(Class clazz) {
            this.clazz = clazz;
            multibinder = Multibinder.newSetBinder(binder(), clazz);
        }

        public Multibinder toAnnotatedClasses(Class bindingAnnotation) {
            return toAnnotatedClasses(bindingAnnotation, clazz.getPackage().getName());
        }

        public Multibinder toAnnotatedClasses(Class bindingAnnotation, String basePackageName) {
            for (Class clazz : AnnotationUtil.getAnnotatedClasses(bindingAnnotation, basePackageName)) {
                multibinder.addBinding().to(clazz);
            }
            return multibinder;
        }

        public LinkedBindingBuilder addBinding() {
            return multibinder.addBinding();
        }
    }
}

As you can see the multibind method returns an AdvancedMultibinder. We cannot extend Multibinder because it has a private Constructor, so instead I use the multibinder internally and call methods on it to add bindings.

The AdvancedMultibinder has a method toAnnotatedClasses, which takes the annotation class as a parameter and adds a binding for each annotated class.

Now we can do the following.

     AdvancedMultibinder multibinder = multibind(ISnack.class);
     multibinder.toAnnotatedClasses(Snack.class);

     // Add a non annotated class to the bind.
     multibinder.addBinding().to(Skittles.class);

     bind(Machine.class).to(SnackMachine.class);

I have attached the example project here so you can look into the code yourself.

Consider the following scenario: we have a FormComponent which has an AjaxBehavior added to it. We want to test that behavior. Depending on the selected value of for instance a RadioChoice, the Ajaxbehavior should show one component and hide another.

You would think that this would be out of the box behavior when using WicketTester, but unfortunately this is not the case. Triggering an Ajaxbehavior is easy using WicketTester, but setting the selected value isn’t.

So we have the following code:

public class TestPage extends WebPage {

    private Label l1;
    private Label l2;
    private WebMarkupContainer container;

    public TestPage() {
        container = new WebMarkupContainer("container");
        container.setOutputMarkupPlaceholderTag(true);

        l1 = new Label("true", "I selected true");
        l1.setVisible(false);
        l1.setOutputMarkupPlaceholderTag(true);
        l2 = new Label("false", "I selected false");
        l2.setVisible(false);
        l2.setOutputMarkupPlaceholderTag(true);

        container.add(new SingleLineRadioChoice("choice", new Model(),
       Arrays.asList(Boolean.TRUE, Boolean.FALSE)) {
            private static final long serialVersionUID = 1L;
            @Override
            public void onUpdateBehavior(AjaxRequestTarget target) {
                if(getModelObject()) {
                    l1.setVisible(true);
                    l2.setVisible(false);
                } else {
                    l1.setVisible(false);
                    l2.setVisible(true);
                }
                target.addComponent(container);
            }
        }, l1, l2);
        add(container);
    }

    public class SingleLineRadioChoice extends RadioChoice {
        private static final long serialVersionUID = -6650798211067977383L;

        public SingleLineRadioChoice(String id,  IModel model, List choices) {
            super(id, model, choices);
            setSuffix("");
            add(new AjaxFormChoiceComponentUpdatingBehavior() {
                private static final long serialVersionUID = 1L;
                @Override
                protected void onUpdate(AjaxRequestTarget target) {
                    updateModel();
                    onUpdateBehavior(target);
                }
            });
        }

        /**  @param target The {@link AjaxRequestTarget}. */
        public void onUpdateBehavior(AjaxRequestTarget target) { }

    }
}

The way you should normally expect the test to work is:

 public void testShouldShowL2() {
        tester.assertInvisible("container:false");
        tester.setParameterForNextRequest("container:choice", "true");
        tester.executeBehavior((AbstractAjaxBehavior)
        tester.getComponentFromLastRenderedPage("container:choice").getBehaviors().get(0));
        tester.assertVisible("container:false");
    }

Unfortunately this doesn’t work because the WicketTester method executeBehavior calls
tester.getServletRequest().setRequestToRedirectString(url.toString()) which sets the
selected value to null.

To be able to test this behavior I created a method om my BaseTest class which looks like this:

   /**
     * Wicket tester.executeBehavior calls
     * tester.getServletRequest().setRequestToRedirectString(url.toString()) which sets the
     * selected value to null. To keep the value call tester.getServletRequest()
     * .setParameter(id, value) after tester.getServletRequest().setRequestToRedirectString
     *(url.toString())
     * @param id The wicket:id.
     * @param value The value that should be selected The value should be the selected index
     * from the list starting with 0.
     */
    public void executeBehavior(String id, String value) {
        AbstractAjaxBehavior behavior = (AbstractAjaxBehavior)
        tester.getComponentFromLastRenderedPage(id).getBehaviors().get(0);
        CharSequence url = behavior.getCallbackUrl(false);
        WebRequestCycle cycle = tester.setupRequestAndResponse(true);
        tester.getServletRequest().setRequestToRedirectString(url.toString());
        tester.getServletRequest().setParameter(id, value);
        tester.processRequestCycle(cycle);
    }

Now you can test the behavior like this.

  public void testShouldShowL2() {
        tester.assertInvisible("container:false");
        executeBehavior("container:choice", "1");
        tester.assertVisible("container:false");
    }

This blog describes how to test Wicket applications using Fitnesse. It is about stretching the limits of the Wicket test components to do so. We will try to explain this by using a small example project we have created to illustrate things. This example project has been inspired on the new user wizard example by Eelco Hillenius. We adapted this example so that it uses Spring, because most apps use a backend system.

For those who don’t know what Fitnesse is: FitNesse is a web server, a wiki, and a software testing tool. FitNesse allows users to enter specially formatted input (its format is accessible to non-programmers). This input is interpreted and tests are created automatically. So Fitnesse offers great options for automated testing beyond your unit tests. Wicket has got some utilities to unit test your application GUI outside a container. These components are org.apache.wicket.util.tester.WicketTester and specifically for Form components there is org.apache.wicket.util.tester.FormTester. Would it not be great if we could use these unit test components for functional testing in Fitnesse?

Forms can be tested using the FormTester. But unfortunately, the FormTester is meant to test one form and as usual in a unit test, you write a seperate testcase per scenario. From a functional point of view, you might want to test a form submit, then go back to the page, correct some validation issues and re-submit the form.
In real life, we used an abstract fixture class to provide all the generic methods and an extended fixture that gives us all the implementation details (like the correct application context, model class, start page, etc). The abstract fixture has for instance methods to check if components exist, set and select methods and lots more. See the example project.
Furthermore, throughout the code you will see several boolean return values that seem unused. This is a fitnesse best-practice. Whenever a boolean is returned, the Fitnesse test will color the result cell green or red so you can verify that the method was executed.

Testing the wizard
So for those who do not know the Wizard component, a wizard component is a dialog component that takes it’s users through a number of predefined steps. It has common functionality like a next, previous, finish and cancel button, and it uses a transition rules to let clients navigate through it’s steps.

Here’s a typical fitnesse table that you might want to use to test your flow:

Look’s easy enough, right? Well, there are quite some steps to take to achieve this easy testing scenario, and of course a couple of problems.

Problem 1: using field values instead of index numbers
Normally, using WicketTester you must define indexes for all fields that you want to test. When writing unit tests, this is not a problem but since we want to cater for functional testing, we will have to use reflection to achieve this.

We will not be going in to the ReflectionUtils, but the setFieldValueThroughSetMethod sets a value for a specific field through the corresponding Set method.
Since we tend to use ListView components for repeating form elements, we also added a special method to be able to add a value to a component at a certain position in the list that the ListView uses.

Problem 2: submitting multiple times and keeping you feedback
The actual submit has several problems to solve:
FormTester only allows one RequestCycle, meaning you can only submit a form once after which you must setup your testcase again. The formtester also does not update the model since it only tests one step.
Since the submit only tests the local step, we have to call .onSubmit() on the Next-button to proceed to the next step.
Feedback messages get lost if you submit a form using both FormTester and WicketTester. When you set a field value, store this value in a Map that will be used as a cache.

On submit, first retrieve the WebSession and remove all feedback messages.
Then set any field values that you have cached on the form again.
We then submit the FormTester to validate the form behavior and when all goes well (meaning there are no error messages caused by validating the form entries) we move to the next step.

Problem 3: ListViews do not get rendered automatically
Because you cannot update values on unrendered components, we will have to render our ListView components manually. Therefore, when moving to another step, we should render the components, see RenderComponents() in the Abstract Fixture.

Problem 4: Map values to Object attributes.
Because rendered values are Strings, for Example in our example application we have a User object which has a List of Role’s, we only display the roleName of the Role object.
We need to be able to map an input string to an Object attribute.
So if in fitnesse we say

One of the nice things about a component-based framework is that your GUI components are backed by real Java objects. However, this makes it harder to test if a field is filled as expected. When setting up a fixture, we need to create a map of Object types and their corresponding GI fields.
Add this to your initialize method:
addTypeAndFieldName(“Role”, “roleName”);
addCustomComponent(“org.apache.wicket.markup.html.basic.Label”);
addCustomComponent(“org.apache.wicket.markup.html.list.ListView”);

So lets illustrate a couple of tests.

Test 1:
- Check if the expected components exist on the NewUserWizardPage.

In your browser the page look like this:

The fitnesse test looks like this:

As you can see it is easy and readable. As you can see, our test is comform point 3. The testers do not need to fill in the Fully Qualified Name for RequiredTextField. To be able to do this, we keep an internal map of components fully qualified names. If you have Components that does not reside in the package org.apache.wicket.markup.html.form., you have to add them by adding a line like addCustomComponent(“org.apache.wicket.markup.html.basic.Label”); to the initialize method in the fixture.)

Test 2:
- Press the “Next” button and check if there are any errors and if we are on the correct Step in the wizard.

In your browser the page look like this:

The fitnesse test looks like this:

Test 3:
- Fill in username and press the “Next” button and check if there are any errors and if we are on the correct Step in the wizard, then fill in email address and press the “Next” button and check if there are any errors and if we are on the correct Step in the wizard.

The fitnesse test looks like this:

These are just a few examples of how to test you wicket application using fitnesse.
As you can see, it make it very easy to test and it is readable!!

By combining the power of Fitnesse and Wicket , we are enabling non-techies to write automated tests. This way, your UI is tested completely in each iteration within a few hours, this gives us a major quality improvement and it really speeds up the testing (imagine how much time it would take to do a regression test by hand!). Our project proved the combination to be very valuable to both developers, testers and our customer.

The sources of the example project can be found here. Read the installation.txt file in the directory src/main/documents to get you started with the example app.

In wicket you can use a ListView iterate over a List of Objects and display them in a table like manner.
This blog describes how you can update ListView data and modify the css for each cell.

So how do we start?

Well first we need to create a ListView. Lets call it view.
But before we do that we need a List of objects we want to display. So lets create it.
I use a List of TestObject’s.

As you can see below, this isn’t very hard.

private ListView view;
private List objects;

objects = Arrays.asList(new TestObject[] {
    new TestObject("one", true),
    new TestObject("two", false),
    new TestObject("three", true)});

view = new ListView("view", objects) {
    @Override
    protected void populateItem(ListItem item) {
        Label label = new Label("label", new PropertyModel(item.getModel(), "name"));
        label.setOutputMarkupId(true);
        item.add(label);
    }
};

Next we will create an IndicatingAjaxFallbackLink which is basically a AjaxLink that shows an indicator.

private IndicatingAjaxFallbackLink link;

link = new IndicatingAjaxFallbackLink("link") {
    @Override
    public void onClick(AjaxRequestTarget target) {
        objects = Arrays.asList(new TestObject[] {
            new TestObject("four", false),
            new TestObject("five", true),
            new TestObject("six", false)});
        view.setList(objects);
        target.addChildren(view, Label.class);
    }
};

Thats all. Now see that we add a new List of objects to the ListView. To make sure the ListView is updated we add

target.addChildren(view, Label.class);

instead of

target.addComponent(view);

. As a ListView is a repeater, we cannot updated it, but we can update components in a ListView.

So now we can update a ListView, but how do we change the css for each field?

We add an AttributeModifier. In the populateItem method show above we just add the following

label.add(new AttributeModifier("class", true, new PropertyModel(item.getModel(), "odd") {
    @Override
    public Object getObject() {
        return ((Boolean) super.getObject()) ? "odd" : "even";
    }
}));

The getObject method is overridden, because the method getOdd() on the TestObject returns a boolean. So instead of returning true or false, it now returns “odd” or “even” which are css class styles.

That’s it.

I have attached the example project here so you can look into the code yourself.

Today’s keynote was all about toys. The guys from the Netbeans team showed some new features such as a JavaScript editor (which contains code completion), Sentilla showed there small sensor thingies, which you can program to gather information, such as acceleration, temperature etc.., LiveScribe showed there very cool pen and lots more.

Today’s topic included:

• User Experience
• SOA
• Semantic Web

Mischa and Erik Jan on The Layperson’s Guide to Building a Better User Experience

Burk Hufnagel showed in his presentation how to leverage the skills you already have and build experiences that delight your users.

The term “User Experience” describes how people feel about using something. This is very important, because if the experience isn’t satisfying,

• The ability to get things done is slow.
• The software will be replaced by software that does have a satisfying experience.

The Layperson’s guide is a guide for non-experts, on how to develop the best “User Experience” for the target group.

So what affects the user’s experience?

• Interaction Design
• How the users thinks it works.
• How the system is actually built.
• How the system presents itself to the user

Doing Test Driven Design has a couple of benefits like

• Writing tests first makes it easier to you create the right interfaces and behaviors later.
• Writing tests first can reduce the chances of the implementation model leaking into the representation model.

So how do you start? Well identifying the Key users is a good start.
They are te ones that must be satisfied for the product to succeed in the market.
Next you need to develop Persona’s, figure out there behavior, motivation and goals. It may take some time to get to the
bottom of this, but it is better then to guess what they want. Try to limit the amount of persona’s, because you need to create
an interface for all of them, to be able to get the best User Experience for all Key Users.

Developing like this may take a little more time on startup, but will gain a lot in the end.

Jeroen on the Semantic Web
Today I had another talk on the Semantic Web, this time a real Technical Session by one of the same guys who talked in yesterday’s discussion panel, Dean Allemang from TopQuadruant. His talk was similarly titled as his book: Semantic Web for the Working Ontologist.

One of the best ways to describe the semantic web is probably using the following sentence: From data on the web to a Web of Data. Our current Web mostly consists of data that us humans can interpret as meaningful, but it has no meaning whatsoever to machines. In the Semantic Web, it is all about adding another dimension to data so that both humans and computers can reason about the data.

One of the standards for the Semantic Web is the Resource Description Framework (RDF). RDF is a way of storing data as triples (subject, predicate, object) distributed across a network, using URI’s as identifiers for the data. For instance if I wanted to model the plays Hamlet and Romeo and Juliet written by Shakespeare in RDF I could write down the following:

(1, my:writer, Shakespeare)
(1, my:title, Hamlet)
(2, my:writer, Shakespeare)
(2, my:title, Romeo and Juliet)

However as you can see, my:title could be very different from your:title. Where my:title is the title of the play, your:title could be your degree, like “MSc.”. This means that the first requirement for the Semantic Web is that we need to agree to disagree. Using namespacing we can assign different meanings to the same terms.

The Semantic Web is all about data, and not about how you represent the data. Yo can chose your own representation and map that to someone else’s representation. For example, if I wanted to say that my:writer is the same as a Dubblin Core author, I could write down the following RDF triple:

(my:writer, owl:equivalentProperty, dc:author)

Now anyone knows that if I say writer, I am actually talking about an author. What is nice is that RDF is used for both the data, as well as the schema. Usig these constructions we can build an ontology. An ontology is best described as: A reusable component of a distributed semantic model. A well known example of an ontology is the Dublin Core standard.

This primer into the Semantic Web was pretty good and clear. I hope they’ll give some more talks on this subject.

Marco on his day
Keynote: extreme innovation
This one was about some of the really cool things you can do with Java. The absolute highlight was the Pulse smartpen, a Java-enabled pen that can not only record what you write & what you hear at the same time, but also order a cup of coffee. In Mandarin. Also noteworthy was a car that can drive & park by itself, which will become hugely popular amongst Asian people & women, I hope.

Designing GUI’s 101: From User Needs To Usable GUI’s
Thank heaven this one only lasted for about 30 minutes, as absolutely nothing new was said (“so we first need to ask the users what they want, then create a prototype, and then ask the same users again what they think of it? Brilliant!”).

Using SOA, EAI, and BPM to reengineer Legacy Applications to Java 2 Platform, Enterprise J2EE Platform
A real-life story about how to drag a legacy system kicking & screaming into the 21st century. I really dug this one, with a very energetic speaker talking about how they wanted to save 30 years of business logic stored in the system by putting JNI on top of it, then later taking another step into the future with SOA. One lesson learned: apparently it’s easier to teach Java developers assembly code than vice versa. Which should insult me in some way as I started out doing machine language, but I’m just too tired to care at this point.

Open Source Development Tools fir the Java Platform, Enterprise Edition (Java Platform), Web 2.0 and SOA
The final session I attended and it sure was hot, temperature wise that is. The demo gods still seemed to be angry, resulting in the room telling the presenter what to do, instead of the other way around (rule #61: if there is a stack trace, study it to see what is wrong – it will save time). After a change of subject (JBoss ESB instead of Seam) things got pretty interesting again, too bad it wasn’t possible anymore to get hold of the free development cd.

Epilogue
It was really clear that this was the last day, as both the number of visitors and the energy level of those still present was down. After attending so many sessions (and writing about them to boot) I myself am ‘stuffed’, but all things considered it was a fantastic experience, and I certainly learned a lot. I’m glad I decided to concentrate on one track (SOA), even though it means I missed out on some other great presentations. Then again, my esteemed colleagues saw those, and I’m pretty sure they will blog about it as well somewhere else.

What do you mean, they share this space with me? I’m a star damn it, I deserve my own space! Now go get me some monkeys!

For creating a Select box there are multiple options available. You can use a ListChoice for selecting a single option or a ListMultipleChoice for selecting multiple options.

So how do we start?

Well, first we need to create two ListMultipleChoice object. Lets give them the following names: originals and destinations

As you can see below, this isn’t very hard.

  // The Selected options in the list choices.
  private List selectedOriginals;
  private List selectedDestinations;

ListMultipleChoice originals = new ListMultipleChoice("originals",
  new PropertyModel(this, "selectedOriginals"), new LoadableDetachableModel() {
      @Override
      protected Object load() {
        return Arrays.asList(new String[] {"one", "two", "three", "four", "five", "six"});
      }
    });

ListMultipleChoice destinations = new ListMultipleChoice("destinations",
   new PropertyModel(this, "selectedDestinations"), new LoadableDetachableModel() {
      @Override
      protected Object load() {
        return new ArrayList();
      }
    });

and the matching HTML part:

Next we need two buttons, one for adding and one for removing options from a select box.

AjaxButton add = new AjaxButton("add") {
      @Override
      protected void onSubmit(AjaxRequestTarget target, Form form) {
            update(target,selectedOriginals, originals, destinations);
      }
    };

AjaxButton remove = new AjaxButton("remove") {
       @Override
      protected void onSubmit(AjaxRequestTarget target, Form form) {
           update(target, selectedDestinations, destinations, originals);
      }
    };

  /**
   * Updates the select boxes.
   * @param target The {@link AjaxRequestTarget}.
   */
  private void update(AjaxRequestTarget target, List selections, ListMultipleChoice from, ListMultipleChoice to) {
    for (String destination : selections) {
      List choices = getChoices(from);
      if (!to.getChoices().contains(destination)) {
        to.getChoices().add(destination);
        choices.remove(destination);
        from.setChoices(choices);
      }
    }
    target.addComponent(to);
    target.addComponent(from);
  }

and the matching HTML part:

As you can see I use an AjaxButton, which is basically what you want for this example. We do not want to do a full page reload.

That’s it.

Next thing we want to do is create a component that does all of this, so we can reuse it. After analysing, I found out that we only need a method which retrieves all options. I have called it getOriginalChoices();
If you look into the attached example project, you can see that it is now very easy to use it.

To use the Component you need to do the following:

    ListMultipleChoiceTransfer listMultipleChoiceTransfer = new ListMultipleChoiceTransfer("test"){
      @Override
      public List getOriginalChoices() {
        return Arrays.asList(new String[] {"one", "two", "three", "four", "five", "six"});
      }
    };

and the matching html

ListMultipleChoiceTransfer will be placed here

I have attached the example project here so you can look into the code yourself.

A non ajax enabled Displaytag would do a request to a controller for every action such as a sorting or selecting a next page. This would result in a complete page refresh (step 1-8 ). When we Ajax enable the Displaytag we skip the page refresh and only refresh a specific piece of the page using an exposed service which provides the updated HTML fragment (step 1a-8a).

In the example I am going to use the following technologies:

• Spring
• Hibernate
• Dwr
• Displaytag

The senario is as follows: We want to display episodes in a table. We want to do this in an Ajax way by using DWR. But where do we start?

Well, first of all we create a domain object called Episode.

public class Episode {
   long id;
   String show;
   String name;
   String episode;
   String airDate;
....
}

Next we create a repository.

public class EpisodeRepository extends HibernateDaoSupport {

    public List getAllEpisodes(int firstResult, int maxResults, String orderBy,
    boolean ascending) {
        Criteria criteria = getSession().createCriteria(Episode.class)
            .setFirstResult(firstResult)
	    .setMaxResults(maxResults)
	    .addOrder(ascending ? Order.asc(orderBy) : Order.desc(orderBy));
	    return criteria.list();
	}

    public int getNumberOfEpisodes() {
        Criteria criteria = getSession().createCriteria(Episode.class);
	criteria.setProjection(Projections.count("id"));
	return (Integer)criteria.uniqueResult();
    }
}

And a Jsp containing the Displaytag for presenting the collection of Episodes.
<display:table id="ep" name="eps" sort="external" requestURI="replaceURI" pagesize="30" partialList="true" size="${nrOfEps}">
    <display:setProperty name="basic.empty.showtable" value="true" />
    <display:column title="Show" property="show" sortable="true" sortName="show" />
    <display:column title="Name" property="name" sortable="true" sortName="name" />
    <display:column class="Episode" property="episode" sortable="true" sortName="episode" />
    <display:column title="Airdate" property="airDate" sortable="true" sortName="airDate" />
</display:table>

Note that I use replaceURI as requestURI. This is very important because we are going to replace this with a call to a javascript method. Displaytag creates links like <a href=”repaceURI?d-2332-o=1….”> and this should be replaced by <a href=”javascript:update(‘d-2332-o=1…’)> so that we the links will be Ajax enabled too. Unfortunatly this is not the only thing that we need to update. We need to update the range we are displaying, the page we are currently on and how the data is sorted.

So how do we do that?
Well, we need to expose a service using DWR. DWR is an Ajax toolkit which make it possible to expose services which can then be called from JavaScript. I created an abstract generic class so that you can use it to enable any service you like. The abstract class contains the following method:

public abstract class AbstractExposedDisplayTagService implements InitializingBean {

    public void afterPropertiesSet() throws Exception {
        ....
    }

    public String findAllObjects(String criteria) {
        WebContext wctx = WebContextFactory.get();
	HttpServletRequest request = wctx.getHttpServletRequest();

	// split results and set values;
	int maxResults = Integer.parseInt(getCriterionValue(criteria, "maxResults", DEFAULT_MAXIMUM_RESULTS));
	int page = Integer.parseInt(getCriterionValue(criteria, displayTagPage, "1"));
	boolean ascending = Integer.parseInt(getCriterionValue(criteria, displayTagSortOrder, "1")) == 1 ? true : false;
	String orderBy = getCriterionValue(criteria, displayTagOrderBy, "id");
	int firstResult = (page - 1) * maxResults;
	int numberOfObjects = getNumberOfObjects();

	// set the episodes on the request so dwr can reload the jsp part.
	request.setAttribute(getObjectsName(), getObjects(firstResult, maxResults, orderBy, ascending));
	request.setAttribute(getNumberOfObjectsName(), numberOfObjects);
	try {
	    String html = wctx.forwardToString(viewFragment);
	    html = DisplayTagReplacementUtil.updatePagingHtml(html, page, maxResults, numberOfObjects, displayTagPage);
	    html = DisplayTagReplacementUtil.updateSortOrderHtml(html, ascending, displayTagSortOrder);
	    html = DisplayTagReplacementUtil.updateHtmlLinks(html);
	    return html;
	} catch (ServletException e) {
	    return "";
	} catch (IOException e) {
	    return "";
	}
}
}

And here is the implementation.

public class EpisodeService extends AbstractExposedDisplayTagService {
	private EpisodeRepository episodeRepository;

	@Override
	public int getNumberOfObjects() {
		return episodeRepository.getNumberOfEpisodes();
	}

	@Override
	public String getNumberOfObjectsName() {
		return "numberOfEpisodes";
	}

	@Override
	public List getObjects(int firstResult, int maxResults, String orderBy, boolean ascending) {
		return episodeRepository.getAllEpisodes(firstResult, maxResults, orderBy, ascending);
	}

	@Override
	public String getObjectsName() {
		return "episodes";
	}

	public void setEpisodeRepository(EpisodeRepository episodeRepository) {
		this.episodeRepository = episodeRepository;
	}
}

Now you see that the findAllObjects method calls 3 static update methods on the DisplayTagReplacementUtil class.
These are responsible for the actual Ajax enabling. They use regular expressions to update the links, sorting etc..

Finally we need to add some JavaScript to be able to call the exposed service methods.
The following piece of code should be in the head of the jsp , in which you include the jsp containing the displaytag shown above in.
<script type='text/javascript' src='<c:url value="/dwr/interface/EpisodeService.js"/>'></script>
<script type='text/javascript' src='<c:url value="/dwr/engine.js"/>'></script>
<script type='text/javascript' src='<c:url value="/dwr/util.js"/>'></script>
<link rel="stylesheet" type="text/css" href='<c:url value="/css/displaytag.css"/>' />

and the javascript:
<script type="text/javascript">
function update(criteria) {
EpisodeService.findAllObjects(criteria, function(data) {
dwr.util.setValue("displayTable", data, { escapeHtml:false });
});
}
update("");
</script>


It is now a simple matter of extending the abstract class and you have Ajax enabled your Displaytag .
I have attached the example project here so you can look into the code yourself.