com.buession.httpclient.HttpAsyncClient Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of buession-httpclient Show documentation
Show all versions of buession-httpclient Show documentation
Buession Framework Http Client
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements.
* See the NOTICE file distributed with this work for additional information regarding copyright ownership.
* The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is
* distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and limitations under the License.
*
* =========================================================================================================
*
* This software consists of voluntary contributions made by many individuals on behalf of the
* Apache Software Foundation. For more information on the Apache Software Foundation, please see
* |
* | Copyright @ 2013-2023 Buession.com Inc. |
* +-------------------------------------------------------------------------------------------------------+
*/
package com.buession.httpclient;
import com.buession.httpclient.core.Header;
import com.buession.httpclient.core.RequestBody;
import com.buession.httpclient.core.RequestMethod;
import com.buession.httpclient.core.concurrent.Callback;
import com.buession.httpclient.exception.RequestException;
import java.io.IOException;
import java.net.URI;
import java.net.URL;
import java.util.List;
import java.util.Map;
/**
* Http 异步客户端
*
* @author Yong.Teng
* @since 2.3.0
*/
public interface HttpAsyncClient extends IBaseHttpClient {
/**
* GET 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void get(String url, Callback callback) throws IOException, RequestException{
get(URI.create(url), callback);
}
/**
* GET 请求
*
* @param uri
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URI uri, Callback callback) throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URL url, Callback callback) throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void get(String url, Map parameters, Callback callback) throws IOException,
RequestException{
get(URI.create(url), parameters, callback);
}
/**
* GET 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URI uri, Map parameters, Callback callback) throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URL url, Map parameters, Callback callback) throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void get(String url, List headers, Callback callback) throws IOException, RequestException{
get(URI.create(url), headers, callback);
}
/**
* GET 请求
*
* @param uri
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URI uri, List headers, Callback callback) throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URL url, List headers, Callback callback) throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void get(String url, Map parameters, List headers, Callback callback)
throws IOException, RequestException{
get(URI.create(url), parameters, headers, callback);
}
/**
* GET 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URI uri, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URL url, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void get(String url, int readTimeout, Callback callback) throws IOException, RequestException{
get(URI.create(url), readTimeout, callback);
}
/**
* GET 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URI uri, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URL url, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void get(String url, int readTimeout, Map parameters, Callback callback)
throws IOException, RequestException{
get(URI.create(url), readTimeout, parameters, callback);
}
/**
* GET 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URI uri, int readTimeout, Map parameters, Callback callback)
throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URL url, int readTimeout, Map parameters, Callback callback)
throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void get(String url, int readTimeout, List headers, Callback callback)
throws IOException, RequestException{
get(URI.create(url), readTimeout, headers, callback);
}
/**
* GET 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URI uri, int readTimeout, List headers, Callback callback) throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URL url, int readTimeout, List headers, Callback callback) throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void get(String url, int readTimeout, Map parameters, List headers,
Callback callback) throws IOException, RequestException{
get(URI.create(url), readTimeout, parameters, headers, callback);
}
/**
* GET 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URI uri, int readTimeout, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* GET 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void get(URL url, int readTimeout, Map parameters, List headers,
Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, Callback callback) throws IOException, RequestException{
post(URI.create(url), callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, Map parameters, Callback callback) throws IOException,
RequestException{
post(URI.create(url), parameters, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, Map parameters, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, Map parameters, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, List headers, Callback callback) throws IOException, RequestException{
post(URI.create(url), headers, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, List headers, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, List headers, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, Map parameters, List headers, Callback callback)
throws IOException, RequestException{
post(URI.create(url), parameters, headers, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, RequestBody data, Callback callback) throws IOException, RequestException{
post(URI.create(url), data, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, RequestBody data, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, RequestBody data, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, RequestBody data, Map parameters, Callback callback)
throws IOException, RequestException{
post(URI.create(url), data, parameters, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, RequestBody data, Map parameters, Callback callback)
throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, RequestBody data, Map parameters, Callback callback)
throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, RequestBody data, List headers, Callback callback)
throws IOException, RequestException{
post(URI.create(url), data, headers, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, RequestBody data, List headers, Callback callback) throws IOException,
RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, RequestBody data, List headers, Callback callback) throws IOException,
RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, RequestBody data, Map parameters, List headers,
Callback callback) throws IOException, RequestException{
post(URI.create(url), data, parameters, headers, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, RequestBody data, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, RequestBody data, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, int readTimeout, Callback callback) throws IOException, RequestException{
post(URI.create(url), readTimeout, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, int readTimeout, Map parameters, Callback callback)
throws IOException, RequestException{
post(URI.create(url), readTimeout, parameters, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, int readTimeout, Map parameters, Callback callback)
throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, int readTimeout, Map parameters, Callback callback) throws IOException,
RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, int readTimeout, List headers, Callback callback) throws IOException,
RequestException{
post(URI.create(url), readTimeout, headers, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, int readTimeout, List headers, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, int readTimeout, List headers, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, int readTimeout, Map parameters, List headers,
Callback callback) throws IOException, RequestException{
post(URI.create(url), readTimeout, parameters, headers, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, int readTimeout, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, int readTimeout, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, int readTimeout, RequestBody data, Callback callback) throws IOException,
RequestException{
post(URI.create(url), readTimeout, data, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, int readTimeout, RequestBody data, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, int readTimeout, RequestBody data, Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, int readTimeout, RequestBody data, Map parameters,
Callback callback) throws IOException, RequestException{
post(URI.create(url), readTimeout, data, parameters, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, int readTimeout, RequestBody data, Map parameters, Callback callback)
throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, int readTimeout, RequestBody data, Map parameters, Callback callback)
throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, int readTimeout, RequestBody data, List headers, Callback callback)
throws IOException, RequestException{
post(URI.create(url), readTimeout, data, headers, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, int readTimeout, RequestBody data, List headers, Callback callback)
throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, int readTimeout, RequestBody data, List headers, Callback callback)
throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void post(String url, int readTimeout, RequestBody data, Map parameters,
List headers, Callback callback) throws IOException, RequestException{
post(URI.create(url), readTimeout, data, parameters, headers, callback);
}
/**
* POST 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URI uri, int readTimeout, RequestBody data, Map parameters, List headers,
Callback callback) throws IOException, RequestException;
/**
* POST 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void post(URL url, int readTimeout, RequestBody data, Map parameters, List headers,
Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, Callback callback) throws IOException, RequestException{
put(URI.create(url), callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, Map parameters, Callback callback) throws IOException,
RequestException{
put(URI.create(url), parameters, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, Map parameters, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, Map parameters, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, List headers, Callback callback) throws IOException, RequestException{
put(URI.create(url), headers, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, List headers, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, List headers, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, Map parameters, List headers, Callback callback)
throws IOException, RequestException{
put(URI.create(url), parameters, headers, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, Map parameters, List headers, Callback callback) throws IOException,
RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, Map parameters, List headers, Callback callback) throws IOException,
RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, RequestBody data, Callback callback) throws IOException, RequestException{
put(URI.create(url), data, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, RequestBody data, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, RequestBody data, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, RequestBody data, Map parameters, Callback callback)
throws IOException, RequestException{
put(URI.create(url), data, parameters, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, RequestBody data, Map parameters, Callback callback) throws IOException,
RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, RequestBody data, Map parameters, Callback callback) throws IOException,
RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, RequestBody data, List headers, Callback callback) throws IOException,
RequestException{
put(URI.create(url), data, headers, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, RequestBody data, List headers, Callback callback) throws IOException,
RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, RequestBody data, List headers, Callback callback) throws IOException,
RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, RequestBody data, Map parameters, List headers,
Callback callback) throws IOException, RequestException{
put(URI.create(url), data, parameters, headers, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, RequestBody data, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, RequestBody data, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, int readTimeout, Callback callback) throws IOException, RequestException{
put(URI.create(url), readTimeout, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, int readTimeout, Map parameters, Callback callback)
throws IOException, RequestException{
put(URI.create(url), readTimeout, parameters, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, int readTimeout, Map parameters, Callback callback) throws IOException,
RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, int readTimeout, Map parameters, Callback callback) throws IOException,
RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, int readTimeout, List headers, Callback callback) throws IOException,
RequestException{
put(URI.create(url), readTimeout, headers, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, int readTimeout, List headers, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, int readTimeout, List headers, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, int readTimeout, Map parameters, List headers,
Callback callback) throws IOException, RequestException{
put(URI.create(url), readTimeout, parameters, headers, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, int readTimeout, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, int readTimeout, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, int readTimeout, RequestBody data, Callback callback) throws IOException,
RequestException{
put(URI.create(url), readTimeout, data, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, int readTimeout, RequestBody data, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, int readTimeout, RequestBody data, Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, int readTimeout, RequestBody data, Map parameters,
Callback callback) throws IOException, RequestException{
put(URI.create(url), readTimeout, data, parameters, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, int readTimeout, RequestBody data, Map parameters, Callback callback)
throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, int readTimeout, RequestBody data, Map parameters, Callback callback)
throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, int readTimeout, RequestBody data, List headers, Callback callback)
throws IOException, RequestException{
put(URI.create(url), readTimeout, data, headers, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, int readTimeout, RequestBody data, List headers, Callback callback)
throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, int readTimeout, RequestBody data, List headers, Callback callback)
throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void put(String url, int readTimeout, RequestBody data, Map parameters,
List headers, Callback callback) throws IOException, RequestException{
put(URI.create(url), readTimeout, data, parameters, headers, callback);
}
/**
* PUT 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URI uri, int readTimeout, RequestBody data, Map parameters, List headers,
Callback callback) throws IOException, RequestException;
/**
* PUT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void put(URL url, int readTimeout, RequestBody data, Map parameters, List headers,
Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, Callback callback) throws IOException, RequestException{
patch(URI.create(url), callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, Map parameters, Callback callback) throws IOException,
RequestException{
patch(URI.create(url), parameters, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, Map parameters, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, Map parameters, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, List headers, Callback callback) throws IOException, RequestException{
patch(URI.create(url), headers, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, List headers, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, List headers, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, Map parameters, List headers, Callback callback)
throws IOException, RequestException{
patch(URI.create(url), parameters, headers, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, RequestBody data, Callback callback) throws IOException, RequestException{
patch(URI.create(url), data, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, RequestBody data, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, RequestBody data, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, RequestBody data, Map parameters, Callback callback)
throws IOException, RequestException{
patch(URI.create(url), data, parameters, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, RequestBody data, Map parameters, Callback callback)
throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, RequestBody data, Map parameters, Callback callback)
throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, RequestBody data, List headers, Callback callback)
throws IOException, RequestException{
patch(URI.create(url), data, headers, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, RequestBody data, List headers, Callback callback) throws IOException,
RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, RequestBody data, List headers, Callback callback) throws IOException,
RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, RequestBody data, Map parameters, List headers,
Callback callback) throws IOException, RequestException{
patch(URI.create(url), data, parameters, headers, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, RequestBody data, Map parameters, List headers,
Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, RequestBody data, Map parameters, List headers,
Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, int readTimeout, Callback callback) throws IOException, RequestException{
patch(URI.create(url), readTimeout, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, int readTimeout, Map parameters, Callback callback)
throws IOException, RequestException{
patch(URI.create(url), readTimeout, parameters, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, int readTimeout, Map parameters, Callback callback) throws IOException,
RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, int readTimeout, Map parameters, Callback callback) throws IOException,
RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, int readTimeout, List headers, Callback callback) throws IOException,
RequestException{
patch(URI.create(url), readTimeout, headers, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, int readTimeout, List headers, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, int readTimeout, List headers, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, int readTimeout, Map parameters, List headers,
Callback callback) throws IOException, RequestException{
patch(URI.create(url), readTimeout, parameters, headers, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, int readTimeout, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, int readTimeout, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, int readTimeout, RequestBody data, Callback callback) throws IOException,
RequestException{
patch(URI.create(url), readTimeout, data, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, int readTimeout, RequestBody data, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, int readTimeout, RequestBody data, Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, int readTimeout, RequestBody data, Map parameters,
Callback callback) throws IOException, RequestException{
patch(URI.create(url), readTimeout, data, parameters, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, int readTimeout, RequestBody data, Map parameters, Callback callback)
throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, int readTimeout, RequestBody data, Map parameters, Callback callback)
throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, int readTimeout, RequestBody data, List headers, Callback callback)
throws IOException, RequestException{
patch(URI.create(url), readTimeout, data, headers, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, int readTimeout, RequestBody data, List headers, Callback callback)
throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, int readTimeout, RequestBody data, List headers, Callback callback)
throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void patch(String url, int readTimeout, RequestBody data, Map parameters,
List headers, Callback callback) throws IOException, RequestException{
patch(URI.create(url), readTimeout, data, parameters, headers, callback);
}
/**
* PATCH 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URI uri, int readTimeout, RequestBody data, Map parameters, List headers,
Callback callback) throws IOException, RequestException;
/**
* PATCH 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param data
* 请求数据
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void patch(URL url, int readTimeout, RequestBody data, Map parameters, List headers,
Callback callback) throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void delete(String url, Callback callback) throws IOException, RequestException{
delete(URI.create(url), callback);
}
/**
* DELETE 请求
*
* @param uri
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URI uri, Callback callback) throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URL url, Callback callback) throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void delete(String url, Map parameters, Callback callback) throws IOException,
RequestException{
delete(URI.create(url), parameters, callback);
}
/**
* DELETE 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URI uri, Map parameters, Callback callback) throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URL url, Map parameters, Callback callback) throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void delete(String url, List headers, Callback callback) throws IOException, RequestException{
delete(URI.create(url), headers, callback);
}
/**
* DELETE 请求
*
* @param uri
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URI uri, List headers, Callback callback) throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URL url, List headers, Callback callback) throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void delete(String url, Map parameters, List headers, Callback callback)
throws IOException, RequestException{
delete(URI.create(url), parameters, headers, callback);
}
/**
* DELETE 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URI uri, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URL url, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void delete(String url, int readTimeout, Callback callback) throws IOException, RequestException{
delete(URI.create(url), readTimeout, callback);
}
/**
* DELETE 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URI uri, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URL url, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void delete(String url, int readTimeout, Map parameters, Callback callback)
throws IOException, RequestException{
delete(URI.create(url), readTimeout, parameters, callback);
}
/**
* DELETE 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URI uri, int readTimeout, Map parameters, Callback callback) throws IOException,
RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URL url, int readTimeout, Map parameters, Callback callback) throws IOException,
RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void delete(String url, int readTimeout, List headers, Callback callback) throws IOException,
RequestException{
delete(URI.create(url), readTimeout, headers, callback);
}
/**
* DELETE 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URI uri, int readTimeout, List headers, Callback callback) throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URL url, int readTimeout, List headers, Callback callback) throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void delete(String url, int readTimeout, Map parameters, List headers,
Callback callback) throws IOException, RequestException{
delete(URI.create(url), readTimeout, parameters, headers, callback);
}
/**
* DELETE 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URI uri, int readTimeout, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* DELETE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void delete(URL url, int readTimeout, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void connect(String url, Callback callback) throws IOException, RequestException{
connect(URI.create(url), callback);
}
/**
* CONNECT 请求
*
* @param uri
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URI uri, Callback callback) throws IOException, RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URL url, Callback callback) throws IOException, RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void connect(String url, Map parameters, Callback callback) throws IOException,
RequestException{
connect(URI.create(url), parameters, callback);
}
/**
* CONNECT 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URI uri, Map parameters, Callback callback) throws IOException, RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URL url, Map parameters, Callback callback) throws IOException, RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void connect(String url, List headers, Callback callback) throws IOException, RequestException{
connect(URI.create(url), headers, callback);
}
/**
* CONNECT 请求
*
* @param uri
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URI uri, List headers, Callback callback) throws IOException, RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URL url, List headers, Callback callback) throws IOException, RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void connect(String url, Map parameters, List headers, Callback callback)
throws IOException, RequestException{
connect(URI.create(url), parameters, headers, callback);
}
/**
* CONNECT 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URI uri, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URL url, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void connect(String url, int readTimeout, Callback callback) throws IOException, RequestException{
connect(URI.create(url), readTimeout, callback);
}
/**
* CONNECT 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URI uri, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URL url, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void connect(String url, int readTimeout, Map parameters, Callback callback)
throws IOException, RequestException{
connect(URI.create(url), readTimeout, parameters, callback);
}
/**
* CONNECT 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URI uri, int readTimeout, Map parameters, Callback callback) throws IOException,
RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URL url, int readTimeout, Map parameters, Callback callback) throws IOException,
RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void connect(String url, int readTimeout, List headers, Callback callback) throws IOException,
RequestException{
connect(URI.create(url), readTimeout, headers, callback);
}
/**
* CONNECT 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URI uri, int readTimeout, List headers, Callback callback) throws IOException,
RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URL url, int readTimeout, List headers, Callback callback) throws IOException,
RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void connect(String url, int readTimeout, Map parameters, List headers,
Callback callback) throws IOException, RequestException{
connect(URI.create(url), readTimeout, parameters, headers, callback);
}
/**
* CONNECT 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URI uri, int readTimeout, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* CONNECT 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void connect(URL url, int readTimeout, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void trace(String url, Callback callback) throws IOException, RequestException{
trace(URI.create(url), callback);
}
/**
* TRACE 请求
*
* @param uri
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URI uri, Callback callback) throws IOException, RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URL url, Callback callback) throws IOException, RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void trace(String url, Map parameters, Callback callback) throws IOException,
RequestException{
trace(URI.create(url), parameters, callback);
}
/**
* TRACE 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URI uri, Map parameters, Callback callback) throws IOException, RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URL url, Map parameters, Callback callback) throws IOException, RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void trace(String url, List headers, Callback callback) throws IOException, RequestException{
trace(URI.create(url), headers, callback);
}
/**
* TRACE 请求
*
* @param uri
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URI uri, List headers, Callback callback) throws IOException, RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URL url, List headers, Callback callback) throws IOException, RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void trace(String url, Map parameters, List headers, Callback callback)
throws IOException, RequestException{
trace(URI.create(url), parameters, headers, callback);
}
/**
* TRACE 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URI uri, Map parameters, List headers, Callback callback) throws IOException,
RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URL url, Map parameters, List headers, Callback callback) throws IOException,
RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void trace(String url, int readTimeout, Callback callback) throws IOException, RequestException{
trace(URI.create(url), readTimeout, callback);
}
/**
* TRACE 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URI uri, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URL url, int readTimeout, Callback callback) throws IOException, RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void trace(String url, int readTimeout, Map parameters, Callback callback)
throws IOException, RequestException{
trace(URI.create(url), readTimeout, parameters, callback);
}
/**
* TRACE 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URI uri, int readTimeout, Map parameters, Callback callback) throws IOException,
RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URL url, int readTimeout, Map parameters, Callback callback) throws IOException,
RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void trace(String url, int readTimeout, List headers, Callback callback) throws IOException,
RequestException{
trace(URI.create(url), readTimeout, headers, callback);
}
/**
* TRACE 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URI uri, int readTimeout, List headers, Callback callback) throws IOException, RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URL url, int readTimeout, List headers, Callback callback) throws IOException, RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void trace(String url, int readTimeout, Map parameters, List headers,
Callback callback) throws IOException, RequestException{
trace(URI.create(url), readTimeout, parameters, headers, callback);
}
/**
* TRACE 请求
*
* @param uri
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URI uri, int readTimeout, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* TRACE 请求
*
* @param url
* 请求 URL
* @param readTimeout
* 读取超时时间
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void trace(URL url, int readTimeout, Map parameters, List headers, Callback callback)
throws IOException, RequestException;
/**
* COPY 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void copy(String url, Callback callback) throws IOException, RequestException{
copy(URI.create(url), callback);
}
/**
* COPY 请求
*
* @param uri
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void copy(URI uri, Callback callback) throws IOException, RequestException;
/**
* COPY 请求
*
* @param url
* 请求 URL
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void copy(URL url, Callback callback) throws IOException, RequestException;
/**
* COPY 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void copy(String url, Map parameters, Callback callback) throws IOException,
RequestException{
copy(URI.create(url), parameters, callback);
}
/**
* COPY 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void copy(URI uri, Map parameters, Callback callback) throws IOException, RequestException;
/**
* COPY 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void copy(URL url, Map parameters, Callback callback) throws IOException, RequestException;
/**
* COPY 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void copy(String url, List headers, Callback callback) throws IOException, RequestException{
copy(URI.create(url), headers, callback);
}
/**
* COPY 请求
*
* @param uri
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void copy(URI uri, List headers, Callback callback) throws IOException, RequestException;
/**
* COPY 请求
*
* @param url
* 请求 URL
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void copy(URL url, List headers, Callback callback) throws IOException, RequestException;
/**
* COPY 请求
*
* @param url
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
default void copy(String url, Map parameters, List headers, Callback callback)
throws IOException, RequestException{
copy(URI.create(url), parameters, headers, callback);
}
/**
* COPY 请求
*
* @param uri
* 请求 URL
* @param parameters
* 请求参数
* @param headers
* 请求头
* @param callback
* 异步 HTTP 请求响应处理回调
*
* @throws IOException
* IO 异常
* @throws RequestException
* 请求异常
*/
void copy(URI uri, Map