com.sghd.common.utils.http.AsyncRestOperationsImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of common-utils Show documentation
The newest version!
package com.sghd.common.utils.http;

import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.converter.ByteArrayHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.ResourceHttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter;
import org.springframework.http.converter.xml.SourceHttpMessageConverter;
import org.springframework.web.client.RequestCallback;
import org.springframework.web.client.ResponseExtractor;
import org.springframework.web.client.RestClientException;
import org.springframework.web.client.RestTemplate;

public class AsyncRestOperationsImpl extends RestTemplate implements AsyncRestOperations {
	private ThreadPoolExecutor threadPool;

	// 构造方法
	@SuppressWarnings("rawtypes")
	AsyncRestOperationsImpl(int coreSize, int maxSize, long liveTime, TimeUnit unit,
			ClientHttpRequestFactory requestFactory) {
		// 初始化转换器
		List> converters = new ArrayList<>();
		converters.add(new ByteArrayHttpMessageConverter());
		converters.add(new StringHttpMessageConverter());
		converters.add(new ResourceHttpMessageConverter());
		converters.add(new SourceHttpMessageConverter());
		converters.add(new AllEncompassingFormHttpMessageConverter());
		setMessageConverters(converters );

		// 初始化请求线程工厂
		LinkedBlockingQueue workQueue = new LinkedBlockingQueue();
		ThreadFactory threadFactory = new ThreadFactory() {
			AtomicInteger sn = new AtomicInteger();

			public Thread newThread(Runnable r) {
				int next = sn.getAndIncrement();
				return new Thread(r, "AsyncRestClient:" + next);
			}
		};
		setRequestFactory(requestFactory);
		
		// 初始化请求线程池
		this.threadPool = new ThreadPoolExecutor(coreSize, maxSize, liveTime, unit, workQueue, threadFactory);
	}

	@Override
	public  Future getForObject(final AsyncCallback callback, final String url, final Class responseType,
			final Object... uriVariables) throws RestClientException {
		Future future = threadPool.submit(new Callable() {
			public T call() {
				try {
					T result = getForObject(url, responseType, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
		return future;
	}

	@Override
	public  Future getForObject(final AsyncCallback callback, final String url, final Class responseType,
			final Map uriVariables) throws RestClientException {
		return threadPool.submit(new Callable() {
			public T call() {
				try {
					T result = getForObject(url, responseType, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});

	}

	@Override
	public  Future getForObject(final AsyncCallback callback, final URI url, final Class responseType)
			throws RestClientException {
		return threadPool.submit(new Callable() {
			public T call() {
				try {
					T result = getForObject(url, responseType);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future> getForEntity(final AsyncCallback> callback,
			final String url, final Class responseType, final Object... uriVariables) throws RestClientException {
		return threadPool.submit(new Callable>() {
			public ResponseEntity call() {
				try {
					ResponseEntity result = getForEntity(url, responseType, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future> getForEntity(final AsyncCallback> callback,
			final String url, final Class responseType, final Map uriVariables)
			throws RestClientException {
		return threadPool.submit(new Callable>() {
			public ResponseEntity call() {
				try {
					ResponseEntity result = getForEntity(url, responseType, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future> getForEntity(final AsyncCallback> callback, final URI url,
			final Class responseType) throws RestClientException {
		return threadPool.submit(new Callable>() {
			public ResponseEntity call() {
				try {
					ResponseEntity result = getForEntity(url, responseType);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future headForHeaders(final AsyncCallback callback, final String url,
			final Object... uriVariables) throws RestClientException {
		return threadPool.submit(new Callable() {
			public HttpHeaders call() {
				try {
					HttpHeaders result = headForHeaders(url, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future headForHeaders(final AsyncCallback callback, final String url,
			final Map uriVariables) throws RestClientException {
		return threadPool.submit(new Callable() {
			public HttpHeaders call() {
				try {
					HttpHeaders result = headForHeaders(url, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future headForHeaders(final AsyncCallback callback, final URI url)
			throws RestClientException {
		return threadPool.submit(new Callable() {
			public HttpHeaders call() {
				try {
					HttpHeaders result = headForHeaders(url);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future postForLocation(final AsyncCallback callback, final String url, final Object request,
			final Object... uriVariables) throws RestClientException {
		return threadPool.submit(new Callable() {
			public URI call() {
				try {
					URI result = postForLocation(url, request, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future postForLocation(final AsyncCallback callback, final String url, final Object request,
			final Map uriVariables) throws RestClientException {
		return threadPool.submit(new Callable() {
			public URI call() {
				try {
					URI result = postForLocation(url, request, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future postForLocation(final AsyncCallback callback, final URI url, final Object request)
			throws RestClientException {
		return threadPool.submit(new Callable() {
			public URI call() {
				try {
					URI result = postForLocation(url, request);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future postForObject(final AsyncCallback callback, final String url, final Object request,
			final Class responseType, final Object... uriVariables) throws RestClientException {
		return threadPool.submit(new Callable() {
			public T call() {
				try {
					T result = postForObject(url, request, responseType, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future postForObject(final AsyncCallback callback, final String url, final Object request,
			final Class responseType, final Map uriVariables) throws RestClientException {
		return threadPool.submit(new Callable() {
			public T call() {
				try {
					T result = postForObject(url, request, responseType, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future postForObject(final AsyncCallback callback, final URI url, final Object request,
			final Class responseType) throws RestClientException {
		return threadPool.submit(new Callable() {
			public T call() {
				try {
					T result = postForObject(url, request, responseType);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future> postForEntity(final AsyncCallback> callback,
			final String url, final Object request, final Class responseType, final Object... uriVariables)
			throws RestClientException {
		return threadPool.submit(new Callable>() {
			public ResponseEntity call() {
				try {
					ResponseEntity result = postForEntity(url, request, responseType, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future> postForEntity(final AsyncCallback> callback,
			final String url, final Object request, final Class responseType, final Map uriVariables)
			throws RestClientException {
		return threadPool.submit(new Callable>() {
			public ResponseEntity call() {
				try {
					ResponseEntity result = postForEntity(url, request, responseType, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future> postForEntity(final AsyncCallback> callback, final URI url,
			final Object request, final Class responseType) throws RestClientException {
		return threadPool.submit(new Callable>() {
			public ResponseEntity call() {
				try {
					ResponseEntity result = postForEntity(url, request, responseType);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future put(final AsyncCallback callback, final String url, final Object request,
			final Object... uriVariables) throws RestClientException {
		return threadPool.submit(new Callable() {
			public Void call() {
				try {
					put(url, request, uriVariables);
					if (callback != null)
						callback.onSuccess(null);
					return null;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future put(final AsyncCallback callback, final String url, final Object request,
			final Map uriVariables) throws RestClientException {
		return threadPool.submit(new Callable() {
			public Void call() {
				try {
					put(url, request, uriVariables);
					if (callback != null)
						callback.onSuccess(null);
					return null;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future put(final AsyncCallback callback, final URI url, final Object request)
			throws RestClientException {
		return threadPool.submit(new Callable() {
			public Void call() {
				try {
					put(url, request);
					if (callback != null)
						callback.onSuccess(null);
					return null;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future delete(final AsyncCallback callback, final String url, final Object... uriVariables)
			throws RestClientException {
		return threadPool.submit(new Callable() {
			public Void call() {
				try {
					delete(url, uriVariables);
					if (callback != null)
						callback.onSuccess(null);
					return null;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future delete(final AsyncCallback callback, final String url, final Map uriVariables)
			throws RestClientException {
		return threadPool.submit(new Callable() {
			public Void call() {
				try {
					delete(url, uriVariables);
					if (callback != null)
						callback.onSuccess(null);
					return null;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future delete(final AsyncCallback callback, final URI url) throws RestClientException {
		return threadPool.submit(new Callable() {
			public Void call() {
				try {
					delete(url);
					if (callback != null)
						callback.onSuccess(null);
					return null;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future> optionsForAllow(final AsyncCallback> callback, final String url,
			final Object... uriVariables) throws RestClientException {
		return threadPool.submit(new Callable>() {
			public Set call() {
				try {
					Set result = optionsForAllow(url, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future> optionsForAllow(final AsyncCallback> callback, final String url,
			final Map uriVariables) throws RestClientException {
		return threadPool.submit(new Callable>() {
			public Set call() {
				try {
					Set result = optionsForAllow(url, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public Future> optionsForAllow(final AsyncCallback> callback, final URI url)
			throws RestClientException {
		return threadPool.submit(new Callable>() {
			public Set call() {
				try {
					Set result = optionsForAllow(url);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future> exchange(final AsyncCallback> callback, final String url,
			final HttpMethod method, final HttpEntity requestEntity, final Class responseType,
			final Object... uriVariables) throws RestClientException {
		return threadPool.submit(new Callable>() {
			public ResponseEntity call() {
				try {
					ResponseEntity result = exchange(url, method, requestEntity, responseType, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future> exchange(final AsyncCallback> callback, final String url,
			final HttpMethod method, final HttpEntity requestEntity, final Class responseType,
			final Map uriVariables) throws RestClientException {
		return threadPool.submit(new Callable>() {
			public ResponseEntity call() {
				try {
					ResponseEntity result = exchange(url, method, requestEntity, responseType, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future> exchange(final AsyncCallback> callback, final URI url,
			final HttpMethod method, final HttpEntity requestEntity, final Class responseType)
			throws RestClientException {
		return threadPool.submit(new Callable>() {
			public ResponseEntity call() {
				try {
					ResponseEntity result = exchange(url, method, requestEntity, responseType);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future execute(final AsyncCallback callback, final String url, final HttpMethod method,
			final RequestCallback requestCallback, final ResponseExtractor responseExtractor,
			final Object... uriVariables) throws RestClientException {
		return threadPool.submit(new Callable() {
			public T call() {
				try {
					T result = execute(url, method, requestCallback, responseExtractor, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future execute(final AsyncCallback callback, final String url, final HttpMethod method,
			final RequestCallback requestCallback, final ResponseExtractor responseExtractor,
			final Map uriVariables) throws RestClientException {
		return threadPool.submit(new Callable() {
			public T call() {
				try {
					T result = execute(url, method, requestCallback, responseExtractor, uriVariables);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}

	@Override
	public  Future execute(final AsyncCallback callback, final URI url, final HttpMethod method,
			final RequestCallback requestCallback, final ResponseExtractor responseExtractor)
			throws RestClientException {
		return threadPool.submit(new Callable() {
			public T call() {
				try {
					T result = execute(url, method, requestCallback, responseExtractor);
					if (callback != null)
						callback.onSuccess(result);
					return result;
				} catch (Exception ex) {
					if (callback != null)
						callback.onError(ex);
					throw ex;
				}
			}
		});
	}
}