ES与Redis实现千万级数据的范围查询性能比较，远程 http调用耗时也能降低到0ms

public class AsyncWraper<T> {
    public interface RefProxy<T> {
        T get();
    }
    
    private RefProxy<T> ref;


    public AsyncWraper(RefProxy<T> ref) {
        this.ref = ref;
    }


    public T getRef() {
        // 调用引用对象的get方法获取结果，
        // 对于异步调用，如果请求未得到响应，此时才会阻塞等待结果
        return ref.get();
    }
}

OkHttpUtils.Future<IP2LocationUtils.IP2LocationBean> future 
    = IP2LocationUtils.asyncLocationBy(platform, request.getIp());
bean.setLocationBeanAsyncWraper(new AsyncWraper<>(() -> {
     try {
           return future.get();
     } catch (Exception e) {
           return null;
     }
}));

bean.getLocationBeanAsyncWraper.getRef().getCountryCode();

 /**
     * 异步获取结果，在业务之前发送请求，
     * 在业务需要获取请求结果时再调用get
     */
    public static class Future<T> {


        private Class<T> tClass;
        private volatile T response;
        private volatile Exception exception;


        public Future(Class<T> tClass) {
            this.tClass = tClass;
        }


        void setResponse(OkHttpUtils.Response response) {
            try {
                if (response.code == 200) {
                    try {
                        this.response = JSON.parseObject(response.getBody(), tClass);
                    } catch (Exception e) {
                        this.exception = e;
                    }
                } else {
                    exception = new Exception("response code:" + response.code + ", msg:" + response.getBody());
                }
            } finally {
                this.notifyAll();
            }
        }


        void setException(Exception exception) {
            try {
                this.exception = exception;
            } finally {
                this.notifyAll();
            }
        }


        public T get() throws Exception {
            while (response == null || exception == null) {
                this.wait();
            }
            if (exception != null) {
                throw exception;
            }
            return this.response;
        }


    }


    /**
     * 异步get
     *
     * @param url
     * @return Future:在需要获取结果时，调用getResponse获取返回结果，
     * 如果request过程中出错则会在该方法抛出异常
     */
    public static <T> Future<T> asyncSendRequest(String url, Class<T> tClass) {
        Request.Builder builder = new Request.Builder()
                .url(url)
                .get();
        Future<T> future = new Future<>(tClass);
        getHttpClient().newCall(builder.build()).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                future.setException(e);
            }


            @Override
            public void onResponse(Call call, okhttp3.Response okHttpResponse) throws IOException {
                OkHttpUtils.Response response = new OkHttpUtils.Response();
                response.setCode(okHttpResponse.code());
                if (okHttpResponse.isSuccessful()) {
                    response.setBody(okHttpResponse.body().string());
                }
                future.setResponse(response);
            }
        });
        return future;
    }