Quelle est la bonne façon de mettre en œuvre des méthodes de synchronisation et d'asynchronisation dans une bibliothèque?

Je ne me dérangerais pas avec cette classe de tâches. Faites simplement que votre méthode synchrone effectue tout le travail et appelez-le de manière asynchrone à partir de la méthode asynchrone.

public class DataClient implements Client {

    private RestTemplate restTemplate = new RestTemplate();
    private ExecutorService executor = Executors.newFixedThreadPool(10);

    // for synchronous call
    @Override
    public DataResponse executeSynchronous(DataKey key) {
        DataResponse dataResponse = null;
        String response = null;

        try {
            String url = createURL();
            response = restTemplate.getForObject(url, String.class);

            // it is a successful response
            dataResponse = new DataResponse(response, DataErrorEnum.NONE, DataStatusEnum.SUCCESS);
        } catch (RestClientException ex) {
            PotoLogging.logErrors(ex, DataErrorEnum.SERVER_DOWN, key);
            dataResponse = new DataResponse(null, DataErrorEnum.SERVER_DOWN, DataStatusEnum.ERROR);
        } catch (Exception ex) {
            PotoLogging.logErrors(ex, DataErrorEnum.CLIENT_ERROR, key);
            dataResponse = new DataResponse(null, DataErrorEnum.CLIENT_ERROR, DataStatusEnum.ERROR);
        }

        return dataResponse;
    }

    //for asynchronous call
    @Override
    public Future<DataResponse> executeAsynchronous(final DataKey key) {
        return executor.submit(new Callable<DataResponse>() {
            @Override
            public DataResponse call() throws Exception {
                return executeSynchronous(key);
            }
        });
    }
}

Le code ci-dessus d'exécution de la tâche synchrone via ASYNC est la même chose que tout comme ASYNC. Si tel est l'exigence, je vous suggérerais d'utiliser l'écoute de Google GuiVa. Je ne suis pas un avocat, mais il a des méthodes pour gérer le délai d'attente des tâches, des rappels bien écrits pour gérer les scénarios onsuccès, onFailure. https://code.google.com/p/guava-libries/wiki/listenablefuTureExploigne

Si vous créez un nouveau thread, même en cas d'opération synchrone (lorsqu'il n'est pas requis), cela conduira à une performance touchée. Vous créez essentiellement un nouveau thread (lire comme gaspillage de ressources) sans même en avoir des avantages. Cela étant dit, je pense que le meilleur moyen serait d'envelopper la partie HTTP d'une classe différente. De cette façon, vous utiliseriez le code de l'accès HTTP dans un boîtier synchrone et asynchrone.

public class DataClient implements Client {

    private ExecutorService executor = Executors.newFixedThreadPool(10);
    private RestTemplate restTemplate;
    private void initRestClient(DataKey key){
    if(restTemplate == null)
        restTemplate = new RestTemplate(clientHttpRequestFactory(key));
    }

    private ClientHttpRequestFactory clientHttpRequestFactory(DataKey key) {
        HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
        factory.setReadTimeout(key.getTimeout());
        factory.setConnectTimeout(key.getTimeout());
        //if you need to set otherparams this is the place we can do it extracting from DataKey obj
        return factory;
    }

    // for synchronous call
    @Override
    public DataResponse executeSynchronous(DataKey key) {
        initRestClient(key);
        DataResponse dataResponse = new HTTPAccess(key).performRequest();
        return dataResponse;
    }

    //for asynchronous call
    @Override
    public Future<DataResponse> executeAsynchronous(final DataKey key) {
        return executor.submit(new Callable<DataResponse>() {
            @Override
            public DataResponse call() throws Exception {
                return executeSynchronous(key);
            }
        });
    }
}