Building Java Object Graph with Tour de France results – using screen scraping, java.util.Parser and assorted facilities

Last Saturday, the Tour de France 2011 departed. For people like myself, enjoying sports and working on Data Visualizations on the one hand and far fetched uses of SQL on the other, the Tour de France offers a wealth of data to work with: rankings for each stage in various categories, nationalities and teams to group by, distances and velocity, years to compare with one another and the like. So it has been my intention for some time to get hold of that data in a format I could work with.

Today I finally found some time to get it done. To locate the statistics for the Tour de France editions for the last few years and get them onto my laptop and into my database. This article describes the first part of that journey: how to get the stage results from some source on the internet into my locally running Java program in an appropriate object structure.

My starting point is the official Tour de France website:


This website goes back to 2007 and also has the latest (2011) results. It presents the result in a format pleasing to the human eye – based on an HTML structure that is fairly pleasing to my groping Java code as well.

Analyzing the source of the Tour de France data

I start my explorations in Firefox, using the Firebug plugin. When I select the tab with the results for a particular stage, I inspect the (AJAX) call that is made to retrieve the stage results into the browser:


The URL that was accessed is . When I access that URL directly, I see an HTML fragment with the individual ranking for the 7th stage in 2010. It turns out that with ITG instead of ITE in this URL, I get the overall ranking after the 7th Stage. Using IME in stead of ITE, I get the 7th stage’s climbers’ standing. And so on.

The HTML associated with the stage standing looks like this:


Which is not as user friendly as the corresponding display in the browser:


but still fairly well structured and programmatically interpretable.

Retrieving HTML fragments and parsing in Java

Consuming these HTML fragments with stage standings into my own Java code is very easy. Parsing the data and turning it into sensible Java Objects is slightly more work, but still quite feasible. From the Java Objects I next need to create a persistent storage for the data – that is the subject for another article.

Using the Java URL class and its openStream method to open an InputStream on whatever content can be found at the URL, it is dead easy to start reading the HTML from the Tour de France website into my Java program. I make use of the java.util.Scanner class to work my way through the HTML by Table Row (TR element). When you inspect the HTML fragments, it is clear early on that every individual rider’s entry corresponds with a TR element, so it seems only logical to have the Scanner break up the data by TR.

    private static Stage processStage(int year, int stageSequence, Map<Integer, Rider> riders) throws, {
        String typeOfStanding = "ITE";
         URL stageStanding = new URL(""+year+"/TDF/LIVE/us/"
                                    +(stageSequence==0?"0":stageSequence+"00") +
        InputStream stream = stageStanding.openStream();
        Scanner scanner = new Scanner(stream);
        Stage stage = new Stage();
        boolean first = true;
        boolean firstStanding = true;
        while (scanner.hasNext()) {
            String entry =;
            if (first) {
                first = false;
                Matcher regexMatcher = regexDistance.matcher(entry);
                if (regexMatcher.find()) {
                    String distanceString =;
                    stage.setTotalDistance(Float.parseFloat(distanceString.substring(0, distanceString.length() - 3)));
            if (!first) {
                String[] els = entry.split("/td>");
                if (els.length > 1) { // only the standing-entries have more than one td element
                    Integer riderNumber = Integer.parseInt(extractValue(els[2]));

                    Rider rider=null;
                    if (riders.containsKey(riderNumber)) {
                        rider = riders.get(riderNumber);
                    else {
                        rider = new Rider(extractValue(els[1]),riderNumber, extractValue(els[3]));
                    Standing standing =
                        new Standing(firstStanding ? 1 : (Integer.parseInt(extractValue(els[0]).replace(".", ""))),
                    firstStanding = false;
                    stage.getStandings().add(standing);                }
        } //while
        return stage;

Subsequently, the TR elements need to be broken up in the TD cell elements that contain the rank, rider’s name, their number, the team they ride for and the time for the stage as well as their lag with regard to the winner. I have used a simple split (on /td>) to extract the cells. The final logic for pulling the correct value from the cell is in the method extractValue. Note: this code is not very pretty, and I am not necessarily overly proud of it. On the other hand: it is one-time-use-only code and it is still fairly compact and easy to write and read.

    private static String extractValue(String el) {
        String r = el.split("</")[0];
        if (r.lastIndexOf(">") > 0) {
            r = r.substring(r.lastIndexOf(">") + 1);
        return r.split("<")[0];

I have created a few domain classes: Rider, Stage, Standing (as well as Tour) that are a business domain like representation of the Tour de France result data. Objects based on these classes are instantiated in the processStage method that is being invoked from the processTour method.

    public static void processTour(Tour tour) throws IOException, MalformedURLException {
        if (tour.isPrologue())
          tour.getStages().add(processStage(tour.getYear(),0, tour.getRiders()));

        for (int i=1;i<= tour.getNumberOfStages();i++)  {
            tour.getStages().add(processStage(tour.getYear(),i, tour.getRiders()));

When I run the TourManager class – a class that create a single Tour object for the Tour de France in 2010 –

public class TourManager {

    List<Tour> tours = new ArrayList<Tour>();

    public TourManager() {
        tours.add(new Tour(2010, 20, true));
        try {
        } catch (MalformedURLException e) {
        } catch (IOException e) {

    public static void main(String[] args) {
        TourManager tm = new TourManager();
        for (Tour tour : tm.getTours()) {
            for (Stage stage : tour.getStages()) {
                System.out.println("================ Stage " + stage.getSequence() + "(" + stage.getTotalDistance() +
                                   " km)");
                for (Standing standing : stage.getStandings()) {
                    if (standing.getRank() < 4) {
                        System.out.println(standing.getRank() + "." + standing.getRider().getName());

it will print the top 3 in every stage:



Download the code for this article:TourDeFranceConsumeAndParseToObjectGraph .