CODEWITHSUNDEEP
spring
Marcel Overdijk
Marcel Overdijk

Reputation: 11467

Throttling RestTemplate invocations

Using Spring RestTemplate to invoke client rest calls, would it be possible to throttle these calls? E.g. max 10 concurrent calls.

The RestTemplate itself does not seem to provide this itself so I wonder what the options are.

It would be best to have a generic solution to e.g. also throttle SOAP calls.

Upvotes: 0

Views: 2781

Answers (1)

John R
John R

Reputation: 2096

From the docs:

To create an instance of RestTemplate you can simply call the default no-arg constructor. This will use standard Java classes from the java.net package as the underlying implementation to create HTTP requests. This can be overridden by specifying an implementation of ClientHttpRequestFactory. Spring provides the implementation HttpComponentsClientHttpRequestFactory that uses the Apache HttpComponents HttpClient to create requests. HttpComponentsClientHttpRequestFactory is configured using an instance of org.apache.http.client.HttpClient which can in turn be configured with credentials information or connection pooling functionality.

I'd look into configuring RestTemplate to use HTTP Components and play with setMaxPerRoute and setMaxTotal. If your SOAP client also happens to be using HTTP Components there may be a way to share the Commons HTTP Components settings between the two.

The other option is to roll your own. You could create a Proxy that uses a Semaphore to block until another request is finished. Something along these lines (note that this code is totally untested and is only to communicate the general idea of how you'd implement this): 

public class GenericCounterProxy implements InvocationHandler
{
    private final Object target;
    private final int maxConcurrent;
    private final Semaphore sem; 

    GenericCounterProxy(Object target, int maxConcurrent)
    {
        this.target = target;
        this.maxConcurrent = maxConcurrent;
        this.sem = new Semaphore(maxConcurrent, true);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try
        {
            // block until acquire succeeds
            sem.acquire()
            method.invoke(target, args);
        }
        finally
        {
            // release the Semaphore no matter what.
            sem.release();
        }
    }

    public static <T> T proxy(T target, int maxConcurrent)
    {
        InvocationHandler handler = new GenericCounterProxy(target, maxConcurrent);
        return (T) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            handler);
    }
}

If you wanted to go with this type of approach:

  • You should probably refine the methods for which the proxy acquires the Semaphore since not every method on the target would be subject to throttling (for example, getters for settings).
  • You need to change from RestTemplate to RestOperations which is an interface or change the proxying mechanism to use class based proxying.

Upvotes: 2

Related Questions