Second, you need to patch the unpacked war. Strip out the xstream-1.3 and add the latest snapshot. Also add the latest xmlpull.org API jar to the WEB-INF/lib of the unpacked nexus war.

More info see this JIRA ticket.

java.lang.NoSuchMethodError: javax.xml.ws.WebFault.messageName()Ljava/lang/String;
	at com.sun.xml.ws.model.RuntimeModeler.processExceptions(RuntimeModeler.java:1077)

To solve this add the webservices-api-x.y.jar to the CATALINA_HOME/endorsed directory.

Do NOT add the webservice-rt-x.y.jar to the endorsed directory or you will encounter the following exception:

java.lang.NoClassDefFoundError: javax/servlet/ServletContext
	at com.sun.xml.ws.transport.http.servlet.WSServletDelegate.<init>(WSServletDelegate.java:102)

Distributed version control systems gained a lot of attention over the last few years. There are many hosting providers that offer free DVCS space on the web. But there are situations that you want to run your own private DVCS server and do not want use a publicly and open DVCS like Gitorious, Github or BitBucket. Of-course you can always buy a commercial offering for a private DVCS solution.

The nice thing about a DVCS is that there is not one version, there are multiple ‘versions’ of a source tree. But at some point you do want a central location to store your (releases) sources. In this article I will explain how to setup a Git server on a Windows machine using Apache to server Git request over HTTP.

If you want to know more, Atlassian has an excellent presentation on DVCS, recorded at the Atlassian Summit last June. And Linus Torvalds talk on Git is worth your time: http://www.youtube.com/watch?v=4XpnKHJAok8

msysgit

You will need to install msysgit, I used version msysGit-fullinstall-1.7.6-preview20110708.exe. On my machine I installed msysgit to D:/dev/msysgit

Repositories

Create a directory that contains your Git repositories, for example: D:/dev/repo/git. To get you started, go to the directory and create an empty Git repository.

cd D:/dev/repo/git
git init --bare Test.git

Apache configuration

In this tutorial I use Apache 2.2.19. You need to setup git-http-backend.exe in order to serve Git through Apache. First copy ..\msysgit\mingw\bin\libiconv-2.dll to ..\msysgit\libexec\git-core or else you will get a 500 error from Apache. To test if your setup works run ..\msysgit\libexec\git-core\git-http-backend.exe

Add the following to your Apache conf\httpd.conf:

SetEnv GIT_PROJECT_ROOT D:/dev/repo/git
SetEnv GIT_HTTP_EXPORT_ALL
ScriptAliasMatch \
        "(?x)^/(.*/(HEAD | \
                        info/refs | \
                        objects/(info/[Apache Git server on Windows^/]+ | \
                                 [0-9a-f]{2}/[0-9a-f]{38} | \
                                 pack/pack-[0-9a-f]{40}\.(pack|idx)) | \
                        git-(upload|receive)-pack))$" \
                        "D:/dev/msysgit/libexec/git-core/git-http-backend.exe/$1"

I also made the Apache DocumentRoot point to my Git repos:

DocumentRoot "D:/dev/repo/git"

<Directory "D:/dev/repo/git">
    Options Indexes FollowSymLinks
    AllowOverride All
    Order allow,deny
    Allow from all
</Directory>

The result:

Using the repo

You can create a local copy of this git repo using the clone command.

git clone http://localhost/Test.git

Warning

Make sure that you setup authentication if you do not want your sources to become publicly available. This can be done using the regular Apache authentication modules.

Links

Many thanks to: http://www.jeremyskinner.co.uk/2010/07/31/hosting-a-git-server-under-apache-on-windows/

The specs

The tablet uses the 1GHz Nvidia Tegra 2 processor, has 1GB RAM, a Gorilla Glass multitouch screen (10.1 inches), 1.2 and 5MP cameras, gyroscope, compass, GPS, HDMI output and so on.

Keyboard dock

The keyboard is little more than a dock with a trackpad and battery (without the dock, the battery life drops to 9.5 hours). With the dock Asus claims a battery life of 16 hours.

Once the dock is attached Android presents a mouse cursor. This actually works very good, especially when writing emails and doing quick navigation.

Micro + SD

The device itself has a MicroSD expansion slot. The keyboard dock includes a SD slot. I have not tried them yet. One of the main reasons for not buying the 32GB version was the availability of the memory expansion slot. The device will cost you 100 euro more for the 32GB version while 32GB of MicroSD memory only cost a much as 45 euro.

System update

After the initial setup I got a notification that a system update was available. So I installed it an rebooted the device. For some reason it gave me a black screen after the update installation so I had to reset it after the update by pressing the power button. When it started the device again I noticed that Android 3.1 was installed on it, yeah baby!

Multiple Google accounts

What I like already is that it is very easy to setup multiple Google accounts and switch between them in application. Both my wife and I will be using the device.

Agenda

The build in Google Agenda is one of the features I use most often to synchronize appointments between multiple calendar. The Agenda app in Honeycomb has a fresh and clean interface that is wel usable on tablet format.

Market

The market app is a bit different in Honeycomb from what I am used to on my Android 2.2 phone. One flaw in the Honeycomb market is that you are not able to rate applications in the market app.

Not all apps are ready for Honeycomb yet. Some apps work but a lot of them need to be updated to work on the 3.x version of Android. I have sent a few crash reports to developers already

More to come

I have been playing around with it today but it runs very smooth. I will post some impressions later this week or next week.

I’ll Keep you posted!

Last week the device finally arrived straight out of Hong Kong to my home address in the Netherlands. In this article I will share some of my first impressions and fixes to get the device in a usable state.

Since I was not at home on the first delivery attempt, DHL left me a note that they would try to deliver the device the next day but the note also stated I had to pay 67 euro VAT! WTF?! This was the first surprise. The second delivery attempt was also unsuccessful (who the f*ck is at home during the day?!) so I had to pick up the device at the local DHL service point.

Once I finally had the device at home I unpacked it and was a bit surprised by the size. I am used to a WD TV Live which is ultra small, the Xtreamer is Ultra big when comparing it to the WD TV Live. But it does not look to bad.

I inserted the supplied USB stick in a free USB slot and fired up the device using the remote, but no luck. The remote was not doing that much. I seems that there is an issue with the bios of the first batch of Xtreamer Ultra devices and powering up the device using the remote. Fortunately there is already a bios fix for this, check the following link.

So I powered on the device by hand and tried to select XBMC to start, but the splash is so ultra fast that it booted into the Ultra OS, which is a modified version of Ubuntu. The Ultra OS is absolutely not usable when you are using the Xtreamer Ultra as a HTPC. Resolution way to high, and fonts way to small.

So a did a reset and tried to boot XBMC. Thats when I noticed that the supplied keyboard was doing jack sh!t. How little did I know that the mini keyboard contains a USB stick that you have to pull out of the keyboard and put into a free USB slot. After that the keyboard works ok, but I would not recommend it. The keyboard response is not that great.

Ok, now I had the keyboard working I selected XBMC to boot but nothing happened. Reboot… select Boxeee… nothing happened. WTF?!!!!!!!! At this point I was really pissed off… what a crappy device this is?!!!!! So I started Googling and I found I was not the only one with problems.

I stumbled upon an OpenELEC version of XBMC for the Xtreamer Ultra (latest versions can be found here). Right now I am using this version (updated to r7188). OpenELEC is an embedded Linux version for XBMC. You can install it on your USB stick. With this installer you can create a OpenELEC installation. So basically you need 2 USB sticks or one USB stick (with the installer) and a HDD. I created an USB stick and fired up the device. Finally some results, XBMC booted ok and I got to play a bit with XBMC on the Xtreamer Ultra, yeah!

First I needed to adjust the overscan compensation through the Video calibration screen. Once this was correct and I could view the entire image I was ready to watch a movie. But my enthusiasm was not for long, when I started the first movie I had no audio… I used the Optical audio cable that I had been using for years on my WD TV Live. But no luck. I tried different settings and after two days I gave up. I was ready to send back the device. As a last option I tried a different Optical cable and…. there was sound!!!!!!!! My XBMC Audio Output settings:

• Audio Output: Optical / Coax
• Speaker Configuration: 5.1
• Boost volume level on downmix: off
• Dolby Digital (AC3) capable receiver: on
• DTS capable receiver: on
• Audio output device: HDA Intel iec958
• Passthrough output device: HDA Intel iec958

Happy as a child I fired up a movie (The Hit List) and started watching….I immediately noticed that there was something wrong with the video… there was a vertical sync issue with the video, btw: I did not know this existed until I started Googling. Apparently you can enabled vertical sync to be always on in XBMC, this solved the issue for me. You can enable this via System Settings > Video Output and select Vertical blank sync to Always enabled.

This left me to the only remaining piece, the remote that was not working. On a forum I found that after the bios update, removing the batteries from the remote for a minute and putting it back in made the remote working again… pffff.

So… now one week after I received my device I finally have it up and running. It caused me a lot of headaches already but it is working now. My short conclusion is that this device is capable of being a HTPC but it is not for mainstream users. It has way too much flaws that only geek (am I one?) can solve.

A few links to other resources:

• http://forum.xtreamer.net/forum/507-xtreamer-ultra/
• http://openelec.tv
• http://wiki.xbmc.org/?title=XBMC_Online_Manual
• http://www.mini-itx.com/projects/xbmc-ion/
• http://gathering.tweakers.net/forum/list_messages/1447305

@echo off
%~d0
cd %~dp0 

net stop SABHelper
net stop SABnzbnd 

SABnzbd-helper.exe remove
SABnzbd-service.exe remove 

SABnzbd-service.exe -f %~dp0 install
SABnzbd-helper.exe install 

net start SABnzbd
pause

Now run the script, thats all!

Frameworks like Spring, Google Guice, Seam, etc, are also moving toward standard APIs. Spring 3.0 embraces a lot of standards APIs like JSR303, JSR330, JSR317, which in my opinion is a good thing!

Why move to these new APIs?

It allows developers to focus on one API instead of learning a specific API for each framework. Switch or to other/competing frameworks or upgrading becomes easier. For example, the gap between Spring 3 and Java EE 6 (CDI + EJB3) has become much smaller due to these new standards. A good example were standardisation helps is the JSR 303 Bean Validation API which is supported by both Spring, Hibernate/JPA, JSF, etc.

Springmodules validation

In Spring 3 the JSR 303 Beans Validation API support was introduced which effectively replaces the springmodules validation project. Users of Spring 3 are encouraged to use this new JSR 303 Beans Validation API.

More information

When you want to leverage the standard API in your project, please have a look at the following articles:

http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/validation.html#validation-beanvalidation
http://www.openscope.net/2010/02/08/spring-mvc-3-0-and-jsr-303-aka-javax-validation/

Spring Dependency Injection annotations

Spring and Google have been working on a standardisation for Dependency Injection annotations, result: the JSR 330 specification. This is a standard API for doing annotation based dependency injection. Spring supports this API since Spring 3.0 (http://blog.springsource.com/2009/09/29/spring-framework-3-0-rc1-released/).

More information

Have a look at the following articles:

http://code.google.com/p/atinject/
http://ralf.schaeftlein.de/2009/11/19/spring-3-0-rc-2-and-jsr-330-dependency-injection-for-java/

Hibernate vs Java Persistence API

The Java Persistence API (JPA) was introduced as part of the Java EE 5 and EJB 3 specification. JPA is in a way the formalisation of Hibernate in a Java Specification (JSR). Since the makers of Hibernate were actively involved in this specification there are numberous of simularities between Hibernate and JPA.

Differences between Hibernate and JPA

JPA defines the standard API for using persistence in Java. You can use Hibernate as a JPA implementation. When using JPA developers can leverage the power of a standardised persistence API and still being able to use Hibernate specific functionality if required. But it opens up possibilities to move to EclipseLink or some other JPA implementation.

Hibernate 3.5 – JPA 2.0

In Hibernate 3.5 a lot of Hibernate subprojects have been merged back into the Hibernate core. This makes it easier to configure and use JPA in conjunction with Hibernate. The JSR 303 API was not officially included as a requirement for JPA 2.0 but Hibernate integrates nicely with the validation specification.

Conclusion

There are a lot of examples that demonstrate the benefits of using standard JSR APIs whenever possible. I would advice to use standard APIs whenever possible and only use specific framework functionality when the standards do not provide enough functionality.

gzip encoded content

When invoking RESTful services from a client you typically specify in the client request, using HTTP request headers, what the Accept type is (JSON or XML) and content encoding you support as a client. The RESTful service inspects the HTTP request headers and returns the requested content (if supported). This proces is called content negotiation. Have a look at a sample request below:

Not all services support different types of content encoding and/or return types. Sometimes you find yourself in a situation that you have to invoke services that return specific content types or encoding formats, for example compressed content using gzip compression.

In the HTTP Accept-Encoding header you specify the content encoding you are supporting. When invoking services that use gzip encoding you need to specify the Accept-Encoding: gzip,deflate in the request headers. Spring RestTemplate using commons-httpclient does not add this by default and disallows you to invoke services that requires a client supporting gzip encoding, this typically results in a HTTP 400 Bad Request. In this blog I described an option to solve this problem in the RestTemplate, but thats only part of the solution.

Guess what happens when you invoke a RESTful service using Spring Web MVCs RestTemplate and the content body contains gzip encoded content? You are out of luck… or not? Read on…

Gzip Enabled MarshallingHttpMessageConverter

The RESTful service my collegues were invoking returns XML data in the response body. So the return value of the RESTful service is an XML message, this message will be unmarshalled using an XML unmarshaller like JAXB. The way to do this using Spring Web MVCs RestTemplate is by adding a MessageConvertor called MarshallingHttpMessageConverter to your RestTemplate and you are good to go.

The MarshallingHttpMessageConverter takes care of marshalling and unmarshalling messages passing between the client and RESTful service. But if your service returns gzip encoded content this is not enough. Because the text/xml content of the response body is gzip encoded we first need to deflate the content before JAXB2 is able to unmarshall the content. The response below contains response content that is gzip encoded. The tool I used, SoapUI, already deflated the content for me, but when invoking with the RestTemplate you have to do this yourself:

I created a GzipEnabledMarshallingHttpMessageConverter that supports both gzip and non-gzip encoded content. This message convert only works for XML messages that need to be (un)marshalled. For JSON services you need to implement a different solution. In the MessageConverter I perform a check to see if the Content-Encoding actually is gzip encoded, if so, I use a GZipStreamSource to read the Gzip compressed content from the InputStream of the response body.

The implementation below is a combination of the Spring MarshallingHttpMessageConverter and the AbstractXmlMessageConverter. I had to extend the AbstractHttpMessageConverter because the StreamSource is created within this class.

package com.oudmaijer.rest.spring.xml.message.converter;

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.AbstractHttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.oxm.Marshaller;
import org.springframework.oxm.MarshallingFailureException;
import org.springframework.oxm.Unmarshaller;
import org.springframework.oxm.UnmarshallingFailureException;
import org.springframework.oxm.jaxb.Jaxb2Marshaller;
import org.springframework.util.Assert;

import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import java.io.IOException;
import java.util.List;
import java.util.zip.GZIPInputStream;

/**
 * Add gzip decompression support for HttpResponse body's that are encoded with gzip.
 * <p/>
 * Implements the AbstractHttpMessageConverter in the same way as
 * the Spring AbstractXmlMessageConverter and adds the MarshallingHttpMessageConverter
 * functionality to it.
 *
 * @param <T>
 */
public class GzipEnabledMarshallingHttpMessageConverter<T> extends AbstractHttpMessageConverter<T> {

    private final TransformerFactory transformerFactory = TransformerFactory.newInstance();
    private Marshaller marshaller;
    private Unmarshaller unmarshaller;

    /**
     * Protected constructor that sets the {@link #setSupportedMediaTypes(java.util.List) supportedMediaTypes}
     * to {@code text/xml} and {@code application/xml}, and {@code application/*-xml}.
     */
    public GzipEnabledMarshallingHttpMessageConverter(Jaxb2Marshaller marshaller, Jaxb2Marshaller unmarshaller) {
        super(new MediaType("application", "xml"), new MediaType("text", "xml"), new MediaType("application", "*+xml"));
        Assert.notNull(marshaller, "marshaller must not be null");
        Assert.notNull(unmarshaller, "unmarshaller must not be null");
        this.marshaller = marshaller;
        this.unmarshaller = unmarshaller;
    }

    @Override
    public final T readInternal(Class<? extends T> clazz, HttpInputMessage inputMessage) throws IOException {

        StreamSource streamSource = null;
        boolean gzip = false;
        HttpHeaders headers = inputMessage.getHeaders();
        List<String> contentEncoding = headers.get("Content-Encoding");

        if( headers != null && contentEncoding != null ) {
            for(String contentEncodingString : contentEncoding) {
                if( contentEncodingString != null && "gzip".equalsIgnoreCase(contentEncodingString.trim()) ) {
                    gzip = true;
                }
            }
        }

        if( gzip ) {
            streamSource = new GZipStreamSource(inputMessage.getBody());
        } else {
            streamSource = new StreamSource(inputMessage.getBody());
        }

        return (T) readFromSource(clazz, inputMessage.getHeaders(), streamSource);
    }

    @Override
    protected final void writeInternal(T t, HttpOutputMessage outputMessage) throws IOException {
        writeToResult(t, outputMessage.getHeaders(), new StreamResult(outputMessage.getBody()));
    }

    /**
     * Set the {@link Marshaller} to be used by this message converter.
     */
    public void setMarshaller(Marshaller marshaller) {
        this.marshaller = marshaller;
    }

    /**
     * Set the {@link Unmarshaller} to be used by this message converter.
     */
    public void setUnmarshaller(Unmarshaller unmarshaller) {
        this.unmarshaller = unmarshaller;
    }

    @Override
    public boolean supports(Class<?> clazz) {
        return this.unmarshaller.supports(clazz);
    }

    /**
     *
     * @param clazz
     * @param headers
     * @param source
     * @return
     * @throws IOException
     */
    protected Object readFromSource(Class<?> clazz, HttpHeaders headers, Source source) throws IOException {
        Assert.notNull(this.unmarshaller, "Property 'unmarshaller' is required");
        try {
            return this.unmarshaller.unmarshal(source);
        } catch (UnmarshallingFailureException ex) {
            throw new HttpMessageNotReadableException("Could not read [" + clazz + "]", ex);
        }
    }

    /**
     *
     * @param o
     * @param headers
     * @param result
     * @throws IOException
     */
    protected void writeToResult(Object o, HttpHeaders headers, Result result) throws IOException {
        Assert.notNull(this.marshaller, "Property 'marshaller' is required");
        try {
            this.marshaller.marshal(o, result);
        } catch (MarshallingFailureException ex) {
            throw new HttpMessageNotWritableException("Could not write [" + o + "]", ex);
        }
    }
}

The GZipStreamSource comes from an XML library created by Kohsuke Kawaguchi. I made some minor modifications to the code but the credits for this code goes to Kohsuke.

package com.oudmaijer.rest.spring.xml.message.converter;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.zip.GZIPInputStream;

import javax.xml.transform.stream.StreamSource;

/**
 * {@link StreamSource} that reads from gzip-compressed XML stream.
 * <p/>
 * THIS SOFTWARE IS IN PUBLIC DOMAIN. NO WARRANTY.
 *
 * @author Kohsuke Kawaguchi (kk@kohsuke.org)
 */
public class GZipStreamSource extends StreamSource {

    /**
     * Creates a {@link StreamSource} from a gzip-compressed XML file.
     */
    public GZipStreamSource(File file) throws IOException {
        this(new FileInputStream(file), file.toURI().toURL().toExternalForm());
    }

    /**
     * Creates a {@link StreamSource} from a gzip-compressed stream.
     */
    public GZipStreamSource(InputStream stream) throws IOException {
        super(new GZIPInputStream(stream));
    }

    /**
     * Creates a {@link StreamSource} from a gzip-compressed stream.
     * <p/>
     * <p>This constructor allows the systemID to be set in addition
     * to the input stream, which allows relative URIs
     * to be processed.</p>
     */
    public GZipStreamSource(InputStream stream, String systemId) throws IOException {
        super(new GZIPInputStream(stream), systemId);
    }

    /**
     * Creates a {@link StreamSource} from a gzip-compressed stream.
     *
     * @param url
     * @throws IOException
     */
    public GZipStreamSource(String url) throws IOException {
        this(new URL(url).openStream(), url);
    }
}

Spring configuration

And finally you have to configure your RestTemplate to use the new MessageConverter.

<bean id="httpClientFactory" class="org.springframework.http.client.CommonsClientHttpRequestFactory">
  <constructor-arg ref="httpClient"/>
</bean>
<bean id="restTemplate" class="org.springframework.web.client.RestTemplate">
  <constructor-arg ref="httpClientFactory"/>
  <property name="messageConverters">
    <list>
    <bean class="com.oudmaijer...GzipEnabledMarshallingHttpMessageConverter">
      <constructor-arg ref="jaxbMarshaller"/>
      <constructor-arg ref="jaxbMarshaller"/>
    </bean>
    ...
    </list>
   </property>
</bean>

Conclusion

Using this MessageConverter you can invoke RESTful services that return gzip encoded content. Lets hope Spring adds it to the default message converters in the future because gzip compressed content is an elegant solution when you need to return large messages from a RESTful service.

• Conversation management
• Environment based profiles (ala ruby/grails)
• Configuration enhancements

See the presentation by Juergen Hoeller

http://www.infoq.com/presentations/Spring-3.0-3.1-3.2

More on configuration enhancements in Spring 3.1

http://www.infoq.com/presentations/Configuration-in-Spring-3-1

The Accept-Encoding header for gzip is not being added to the request by spring-android. I have added support for gzip to the RestTemplate and I created a patch for it. See the extended RestTemplate below:

package com.oudmaijer.android.rest;

import org.springframework.http.HttpMethod;
import org.springframework.http.client.ClientHttpRequest;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.util.Assert;
import org.springframework.web.client.*;

import java.io.IOException;
import java.net.URI;

/**
 * Adds support for gzip encoding to the Spring RestTemplate
 */
public class GzipRestTemplate extends RestTemplate {

    /**
     * {@inheritDoc}
     */
    @Override
    protected <T> T doExecute(URI url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor) throws RestClientException {
        Assert.notNull(url, "'url' must not be null");
        Assert.notNull(method, "'method' must not be null");
        ClientHttpResponse response = null;
        try {
            ClientHttpRequest request = createRequest(url, method);
            if( request.getHeaders() != null ) {
                request.getHeaders().add("Accept-Encoding", "gzip,deflate");
            }

            if (requestCallback != null) {
                requestCallback.doWithRequest(request);
            }
            response = request.execute();

            if (!getErrorHandler().hasError(response)) {
                logResponseStatus(method, url, response);
            } else {
                handleResponseError(method, url, response);
            }
            if (responseExtractor != null) {
                return responseExtractor.extractData(response);
            } else {
                return null;
            }
        } catch (IOException ex) {
            throw new ResourceAccessException("I/O error: " + ex.getMessage(), ex);
        } finally {
            if (response != null) {
                response.close();
            }
        }
    }

    private void handleResponseError(HttpMethod method, URI url, ClientHttpResponse response) throws IOException {
        if (logger.isWarnEnabled()) {
            try {
                logger.warn(
                        method.name() + " request for \"" + url + "\" resulted in " + response.getStatusCode() + " (" +
                                response.getStatusText() + "); invoking error handler");
            } catch (IOException e) {
                // ignore
            }
        }
        getErrorHandler().handleError(response);
    }

    private void logResponseStatus(HttpMethod method, URI url, ClientHttpResponse response) {
        if (logger.isDebugEnabled()) {
            try {
                logger.debug(
                        method.name() + " request for \"" + url + "\" resulted in " + response.getStatusCode() + " (" +
                                response.getStatusText() + ")");
            } catch (IOException e) {
                // ignore
            }
        }
    }

}

The least unobtrusive way to change the RestTemplate is not to change it. I decided to override the doExecute method because I want the RestTemplate functionality as it is right now. I also had to included the private functions being called by the RestTemplate. I could have used the exchange() function in the RestTemplate but this is to abstract IMO.

How to use

Instead of instantiating the Spring RestTemplate you can now use the GzipRestTemplate. And example of using the RestTemplate for reading JSON responses:

...
RestTemplate restTemplate = new GzipRestTemplate();
restTemplate.setRequestFactory(new SimpleClientHttpRequestFactory());

List<HttpMessageConverter<?>> mc = restTemplate.getMessageConverters();
MappingJacksonHttpMessageConverter json = new MappingJacksonHttpMessageConverter();

List<MediaType> supportedMediaTypes = new ArrayList<MediaType>();
supportedMediaTypes.add(new MediaType("text", "html"));
supportedMediaTypes.add(new MediaType("application", "json"));
json.setSupportedMediaTypes(supportedMediaTypes);
mc.add(json);
restTemplate.setMessageConverters(mc);

JsonResult jsonResult = restTemplate.getForObject(url, JsonResult.class);
...

And a pom.xml of an application that uses the RestTemplate:

...
<build>
	<sourceDirectory>src</sourceDirectory>
	<finalName>${project.artifactId}</finalName>
	<plugins>
		<plugin>
			<groupId>com.jayway.maven.plugins.android.generation2</groupId>
			<artifactId>maven-android-plugin</artifactId>
			<version>2.8.3</version>
			<configuration>
				<sdk>
					<path>/path/to/android-sdk-windows</path>
					<platform>8</platform>
				</sdk>
				<emulator>
					<avd>my_avd</avd>
				</emulator>
				<deleteConflictingFiles>true</deleteConflictingFiles>
				<undeployBeforeDeploy>true</undeployBeforeDeploy>
			</configuration>
			<extensions>true</extensions>
		</plugin>
		<plugin>
			<artifactId>maven-compiler-plugin</artifactId>
			<version>2.3.2</version>
		</plugin>
	</plugins>
</build>
<dependencies>
        ...
	<dependency>
		<groupId>com.google.android</groupId>
		<artifactId>android</artifactId>
		<version>2.2.1</version>
		<scope>provided</scope>
	</dependency>
	<dependency>
		<groupId>org.springframework.android</groupId>
		<artifactId>spring-android-rest-template</artifactId>
		<version>1.0.0.BUILD-SNAPSHOT</version>
		<scope>compile</scope>
	</dependency>
	<dependency>
		<groupId>commons-httpclient</groupId>
		<artifactId>commons-httpclient</artifactId>
		<version>3.1</version>
		<scope>compile</scope>
	</dependency>
	<dependency>
		<groupId>org.codehaus.jackson</groupId>
		<artifactId>jackson-mapper-asl</artifactId>
		<version>1.6.2</version>
		<scope>compile</scope>
	</dependency>
</dependencies>
<repositories>
	<!-- For testing against latest Spring snapshots -->
	<repository>
		<id>org.springframework.maven.snapshot</id>
		<name>Spring Maven Snapshot Repository</name>
		<url>http://maven.springframework.org/snapshot</url>
		<releases><enabled>false</enabled></releases>
		<snapshots><enabled>true</enabled></snapshots>
	</repository>
	<!-- For developing against latest Spring milestones -->
	<repository>
		<id>org.springframework.maven.milestone</id>
		<name>Spring Maven Milestone Repository</name>
		<url>http://maven.springframework.org/milestone</url>
		<snapshots><enabled>false</enabled></snapshots>
	</repository>
</repositories>
...