any frameworks to handle REST Client server list? [closed]

Question

The idea is that REST Client can be configured with list of REST Servers. So the servers list will rotate on the REST Client in a round robin fashion.

e.g. REST Client Application. I'll be configuring server list (REST_SERVER1,REST_SERVER2, REST_SERVER3)

1 request -> REST_SERVER1
2 request -> REST_SERVER2
3 request  -> REST_SERVER3
4 request -> REST_SERVER1

I searched so much I couldn't found a proper framework that supports this functionality.

Answer 1

On the fear adding a bunch of components to complicate your application setup, I might consider a quick-and-dirty, pure Java solution.

Here's something fun I came up with using Spring's RestTemplate. If you are comfortable with interceptors, aspects, other things that can wrap up a method call, you can apply these principles to wrap up all of the various RestTemplate REST calls. See the RestTemplate javadoc

import org.junit.Test;
import org.springframework.http.HttpMethod;
import org.springframework.web.client.*;
import org.springframework.web.util.UriTemplate;
import org.springframework.web.util.UriUtils;

import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;

public class Stuff {

    // Make this configurable.
    Collection<String> serverList;
    // or do something a little smarter, like this interface. I'll use this in this example.
    ServerLookup serverLookup;

    interface ServerLookup {
        Iterator<String> getValidServerListIterator();
        void markUnreachableServer(String url);
    }

    // Do it externally around RestTemplate...
    @Test
    public void testNormalRestTemplate() throws Exception {
        RestTemplate restTemplate = new RestTemplate();
        Iterator<String> serverIterator = serverLookup.getValidServerListIterator();
        while (serverIterator.hasNext()) {
            String server = serverIterator.next();
            try {
                Object obj = restTemplate.getForObject(server + "/objectIdentifier/511", Object.class);
                break;
            } catch (ResourceAccessException e) {
                serverLookup.markUnreachableServer(server);
            }
        }
    }

    // or you can try to 'enhance' RestTemplate to contain the retry logic within. It's a bit hacky, but more fun.
    @Test
    public void testMyRestTemplate() {
        RestTemplate rt = new MyRestTemplate();
        Object obj = rt.getForObject("/objectIdentifier/511", Object.class);
        rt.delete("/objectIdentifier/511");
    }

    // Here's a way to (hackily) augment RestTemplate with retry functionality
    class MyRestTemplate extends RestTemplate {

        // Unfortunately RestTemplate probably wasn't designed for much extensibility. URI objects can't be made from
        // URL fragments, so these two methods are the 'furthest in' that we can override and cover all RestTemplate
        // REST methods.
        @Override
        public <T> T execute(String url, HttpMethod method, RequestCallback requestCallback,
                             ResponseExtractor<T> responseExtractor, Object... urlVariables) throws RestClientException {

            Iterator<String> serverIterator = serverLookup.getValidServerListIterator();
            while (serverIterator.hasNext()) {
                String server = serverIterator.next();
                // prefix the URL fragment passed in with a server
                String fullUrl = server + url;
                UriTemplate uriTemplate = new HttpUrlTemplate(fullUrl);
                URI expanded = uriTemplate.expand(urlVariables);
                try {
                    return doExecute(expanded, method, requestCallback, responseExtractor);
                } catch (ResourceAccessException e) {
                    serverLookup.markUnreachableServer(server);
                }
            }
            throw new RuntimeException("Unable to reach any servers in the server list for " + url);
        }

        @Override
        public <T> T execute(String url, HttpMethod method, RequestCallback requestCallback,
                             ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables) throws RestClientException {

            Iterator<String> serverIterator = serverLookup.getValidServerListIterator();
            while (serverIterator.hasNext()) {
                String server = serverIterator.next();
                // prefix the URL fragment passed in with a server
                String fullUrl = server + url;
                UriTemplate uriTemplate = new HttpUrlTemplate(fullUrl);
                URI expanded = uriTemplate.expand(urlVariables);
                try {
                    return doExecute(expanded, method, requestCallback, responseExtractor);
                } catch (ResourceAccessException e) {
                    serverLookup.markUnreachableServer(server);
                }
            }
            throw new RuntimeException("Unable to reach any servers in the server list for " + url);
        }

        /** Exact duplicate of the inner class of RestTemplate. Can not touch privates. */
        class HttpUrlTemplate extends UriTemplate {
            public HttpUrlTemplate(String uriTemplate) {
                super(uriTemplate);
            }

            @Override
            protected URI encodeUri(String uri) {
                try {
                    String encoded = UriUtils.encodeHttpUrl(uri, "UTF-8");
                    return new URI(encoded);
                }
                catch (UnsupportedEncodingException ex) {
                    // should not happen, UTF-8 is always supported
                    throw new IllegalStateException(ex);
                }
                catch (URISyntaxException ex) {
                    throw new IllegalArgumentException("Could not create HTTP URL from [" + uri + "]: " + ex, ex);
                }
            }
        }
    }
}

Answer 2

I'd just wrap your client then repeat the request until it succeeds. That way you can neatly keep track of which servers are working. Here's some code I adapted from our system...

import java.io.IOException;
import java.net.URL;
import java.util.Calendar;

import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;

public class RestClient {

    private final String mediaType = "application/json";
    private RestServer[] servers = new RestServer[] {new RestServer("server1", 8080), new RestServer("server2", 8080)};

    protected RestClient() {
    }

    protected ClientResponse post(String methodUrl, Object postData) throws IOException {
        return doRequest(methodUrl, postData, true);
    }

    protected ClientResponse get(String methodUrl) throws IOException {
        return doRequest(methodUrl, null, false);
    }

    private ClientResponse doRequest(String methodUrl, Object postData, boolean isPost) throws IOException {

        Client client = Client.create();

        for (RestServer restServer : servers) {

            if (!restServer.shouldTry()) {
                System.out.println(restServer + " not ready");
                continue;
            }

            System.out.println("Trying with " + restServer);

            try {
                URL url = new URL("http", restServer.getHost(), restServer.getPort(), '/' + methodUrl);
                WebResource webResource = client.resource(url.toString());

                System.out.println("Calling " + url);
                ClientResponse response = isPost
                    ? webResource.type(mediaType).post(ClientResponse.class, postData)
                    : webResource.type(mediaType).get(ClientResponse.class);

                if (response.getStatus() < 300) {
                    restServer.succeeded();
                    return response;
                }

                restServer.failed();

            } catch (Exception ex) {
                System.out.println(restServer + " failed with exception " + ex.getMessage());
                restServer.failed();
            }
        }

        // No servers worked
        return null;
    }
}

class RestServer {

    private final int TIME_TO_WAIT_BEFORE_TRYING_AGAIN = 1000 * 30; // 30 seconds
    private String host;
    private int port;
    private Calendar lastAttempted;
    private boolean lastCallFailed;

    public RestServer(String host, int port) {
        this.host = host;
        this.port = port;
        lastAttempted = Calendar.getInstance();
    }

    public String getHost() {
        return host;
    }

    public int getPort() {
        return port;
    }

    public void failed() {
        lastCallFailed = true;
        lastAttempted = Calendar.getInstance();
    }

    public void succeeded() {
        lastCallFailed = false;
        lastAttempted = Calendar.getInstance();
    }

    public boolean shouldTry() {
        if (!lastCallFailed)
            return true;

        return Calendar.getInstance().compareTo(lastAttempted) > TIME_TO_WAIT_BEFORE_TRYING_AGAIN;
    }

    @Override
    public String toString() {
        return new StringBuilder(host).append(':').append(port).toString();
    }
}