下面列出了java.net.HttpURLConnection#setDoInput ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private void preAuthenticate() throws IOException {
URLConnection conn = null;
// Create a connection for this command
conn = (new URL(url)).openConnection();
HttpURLConnection hconn = (HttpURLConnection) conn;
// Set up standard connection characteristics
hconn.setAllowUserInteraction(false);
hconn.setDoInput(true);
hconn.setUseCaches(false);
hconn.setDoOutput(false);
hconn.setRequestMethod("OPTIONS");
hconn.setRequestProperty("User-Agent", "Catalina-Ant-Task/1.0");
// Establish the connection with the server
hconn.connect();
// Swallow response message
IOTools.flow(hconn.getInputStream(), null);
}
public String getMimeType(Uri uri) {
switch (getUriType(uri)) {
case URI_TYPE_FILE:
case URI_TYPE_ASSET:
return getMimeTypeFromPath(uri.getPath());
case URI_TYPE_CONTENT:
case URI_TYPE_RESOURCE:
return contentResolver.getType(uri);
case URI_TYPE_DATA: {
return getDataUriMimeType(uri);
}
case URI_TYPE_HTTP:
case URI_TYPE_HTTPS: {
try {
HttpURLConnection conn = httpClient.open(new URL(uri.toString()));
conn.setDoInput(false);
conn.setRequestMethod("HEAD");
return conn.getHeaderField("Content-Type");
} catch (IOException e) {
}
}
}
return null;
}
private HTTPResponse post() throws IOException {
URL url = new URL(mPath);
HttpURLConnection lConnection = (HttpURLConnection) url.openConnection();
lConnection.setReadTimeout(mReadTimeoutMillis);
lConnection.setConnectTimeout(mConnectTimeoutMillis);
lConnection.setRequestMethod("POST");
lConnection.setDoInput(true);
lConnection.setDoOutput(true);
OutputStream lOutStream = lConnection.getOutputStream();
BufferedWriter lWriter = new BufferedWriter(new OutputStreamWriter(lOutStream, "UTF-8"));
lWriter.write(getQuery(mParameters));
lWriter.flush();
lWriter.close();
lOutStream.close();
HTTPResponse response = readPage(lConnection);
return response;
}
/**
* Opens an {@link HttpURLConnection} with parameters.
* @param url
* @return an open connection
* @throws IOException
*/
private HttpURLConnection openConnection(URL url, Request<?> request) throws IOException {
HttpURLConnection connection = createConnection(url);
int timeoutMs = request.getTimeoutMs();
connection.setConnectTimeout(timeoutMs);
connection.setReadTimeout(timeoutMs);
connection.setUseCaches(false);
connection.setDoInput(true);
// use caller-provided custom SslSocketFactory, if any, for HTTPS
if ("https".equals(url.getProtocol()) && mSslSocketFactory != null) {
((HttpsURLConnection)connection).setSSLSocketFactory(mSslSocketFactory);
}
return connection;
}
/**
* Opens an {@link HttpURLConnection} with parameters.
*
* @param url
* @return an open connection
* @throws IOException
*/
private HttpURLConnection openConnection(URL url, Request<?> request)
throws IOException {
HttpURLConnection connection = createConnection(url);
int timeoutMs = request.getTimeoutMs();
connection.setConnectTimeout(timeoutMs);
connection.setReadTimeout(timeoutMs);
connection.setUseCaches(false);
connection.setDoInput(true);
// use caller-provided custom SslSocketFactory, if any, for HTTPS
if ("https".equals(url.getProtocol()) && mSslSocketFactory != null) {
((HttpsURLConnection) connection)
.setSSLSocketFactory(mSslSocketFactory);
}
return connection;
}
public MultipartUtility(String requestURL, String charset, long groupId, String authStringEnc, String method)
throws IOException {
this.charset = charset;
// creates a unique boundary based on time stamp
boundary = "===" + System.currentTimeMillis() + "===";
URL url = new URL(requestURL);
httpConn = (HttpURLConnection) url.openConnection();
httpConn.setUseCaches(false);
httpConn.setDoOutput(true); // indicates POST method
httpConn.setDoInput(true);
httpConn.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
httpConn.setRequestProperty("User-Agent", "OpenCPS-Agent");
httpConn.setRequestProperty("Authorization", "Basic " + authStringEnc);
httpConn.setRequestMethod(method);
httpConn.setDoInput(true);
httpConn.setDoOutput(true);
httpConn.setRequestProperty("Accept", "application/json");
httpConn.setRequestProperty("groupId", String.valueOf(groupId));
outputStream = httpConn.getOutputStream();
writer = new PrintWriter(new OutputStreamWriter(outputStream, charset), true);
}
private List<Map<String, String>> getMetrics(List<String> gnocchiNames) {
String metricsUrl = baseUrl + "/v1/metric";
List<Map<String, String>> rawMetrics = new ArrayList<>();
if (isEmpty(gnocchiNames)) {
return rawMetrics;
}
for (String metricName : gnocchiNames) {
String metricUrl = metricsUrl + "?name=" + metricName;
try {
URL url = new URL(metricUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestProperty(AUTHORIZATION, basicAuth);
conn.setRequestMethod(GET);
conn.setDoInput(true);
List rawMetric = JsonUtil.getMapper().readValue(conn.getInputStream(), List.class);
conn.disconnect();
log.debugf("Gnocchi Metrics found %s", rawMetric);
rawMetrics.addAll(rawMetric);
} catch (IOException e) {
log.errorf(e,"Error querying Gnocchi metrics %s", metricUrl);
}
}
return rawMetrics;
}
private HttpURLConnection openConnection(URL url, Request request) throws IOException {
HttpURLConnection connection = createConnection(url);
connection.setConnectTimeout(mHttpHelper.mConnectTimeOut);
connection.setReadTimeout(mHttpHelper.mReadTimeOut);
connection.setUseCaches(false);
connection.setDoInput(true);
if ("https".equals(url.getProtocol()) && mHttpHelper.mSslSocketFactory != null) {
((HttpsURLConnection) connection).setSSLSocketFactory(mHttpHelper.mSslSocketFactory);
}
return connection;
}
@Override
protected AuthResponse doInBackground(String... params) {
try {
URL url = new URL(taigaUrl + "/api/v1/auth");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setReadTimeout(15000);
conn.setConnectTimeout(15000);
conn.setRequestMethod("POST");
conn.setDoInput(true);
conn.setDoOutput(true);
String postData = String.format("type=normal&username=%s&password=%s",
URLEncoder.encode(username, "UTF-8"), URLEncoder.encode(password, "UTF-8"));
try (OutputStream os = conn.getOutputStream();
OutputStreamWriter out = new OutputStreamWriter(os, "UTF-8");
BufferedWriter writer = new BufferedWriter(out)) {
writer.write(postData);
writer.flush();
}
int responseCode = conn.getResponseCode();
Log.w(TAG, "Login response code: " + responseCode);
if (responseCode == HttpsURLConnection.HTTP_OK) {
String jsonResponse = IOUtils.toString(conn.getInputStream());
Log.d(TAG, "Login response: " + jsonResponse);
return new GsonBuilder().create().fromJson(jsonResponse, AuthResponse.class);
}
throw new IllegalStateException(String.valueOf(responseCode));
} catch (Exception e) {
Log.e(TAG, "Error requesting login", e);
return null;
}
}
private boolean connectToPingUrl(URL url) throws IOException {
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setConnectTimeout(500);
connection.setRequestMethod("GET");
connection.setDoOutput(true);
connection.setDoInput(true);
connection.connect();
int responseCode = connection.getResponseCode();
connection.disconnect();
logger.debug("Got {} from {}.", responseCode, url);
return responseCode == 200;
}
public static String getSearchJsonStr(String keywordStr) throws UnsupportedEncodingException {
// String requestUrl = "http://gank.io/api/search/query/listview/category/"
// + URLEncoder.encode(gankClassStr, "utf-8") + "/count/30/page/1 ";
String requestUrl = "http://gank.io/api/search/query/"
+ URLEncoder.encode(keywordStr, "utf-8") + "/category/all/count/50/page/1";
StringBuffer buffer = null;
try {
// 建立连接
URL url = new URL(requestUrl);
HttpURLConnection httpUrlConn = (HttpURLConnection) url.openConnection();
httpUrlConn.setDoInput(true);
httpUrlConn.setRequestMethod("GET");
// 获取输入流
InputStream inputStream = httpUrlConn.getInputStream();
InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
// 读取返回结果
buffer = new StringBuffer();
String str = null;
while ((str = bufferedReader.readLine()) != null) {
buffer.append(str);
}
// 释放资源
bufferedReader.close();
inputStreamReader.close();
inputStream.close();
httpUrlConn.disconnect();
} catch (Exception e) {
e.printStackTrace();
}
if (buffer != null) {
return buffer.toString(); //返回获取的json字符串
} else {
return "";
}
}
private static HttpURLConnection createConnection() throws Exception {
URL url = new URL(PROFILE_URL);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/json");
connection.setUseCaches(false);
connection.setDoInput(true);
connection.setDoOutput(true);
return connection;
}
private HttpURLConnection getHttpURLConnection(String uri, String referer, String method) throws IOException {
URL url = new URL(uri);
HttpURLConnection httpConn = (HttpURLConnection) url.openConnection();
httpConn.setRequestProperty("Content-Type","application/x-www-form-urlencoded;charset=UTF-8");
httpConn.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.95 Safari/537.11");
if(referer != null && "".equals(referer))
{
httpConn.setRequestProperty("Referer", referer);
}
httpConn.setRequestMethod(method);
httpConn.setDoInput(true);
return httpConn;
}
private static int postData( String path, String payload ) throws IOException {
URL url = new URL( path );
HttpURLConnection con = (HttpURLConnection)url.openConnection();
con.setRequestMethod("POST");
con.setRequestProperty("Content-Type","application/json");
con.setDoOutput(true);
con.setDoInput(true);
con.setConnectTimeout( 10000 );
con.setReadTimeout( 20000 );
con.getOutputStream().write( payload.getBytes("UTF-8") );
con.getOutputStream().flush();
con.getOutputStream().close();
int status = con.getResponseCode();
if( status != 200 ) {
return status;
}
//read the response
byte[] buffer = new byte[ 1024 ];
while( con.getInputStream().read( buffer ) > 0 ) {
;
}
return 200;
}
/**
* Run a http post request
*
* @param entityName
* @param body
* @return http response
* @throws MalformedURLException
* @throws IOException
* @throws ProtocolException
*/
public static HttpResponse executePostRequest(String entityName, String body)
throws MalformedURLException, IOException, ProtocolException {
URL url = new URL(SERVICE_ROOT_URI + entityName);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
try {
connection.setRequestMethod("POST");
connection.setDoInput(true);
connection.setDoOutput(true);
connection.setUseCaches(false);
connection.setRequestProperty("Accept",
"application/atom+xml");
connection.setRequestProperty("Content-Type",
"application/atom+xml");
DataOutputStream outStream = new DataOutputStream(
connection.getOutputStream());
try {
outStream.writeBytes(body);
outStream.close();
return new HttpResponse(connection);
} finally {
outStream.close();
}
} finally {
connection.disconnect();
}
}
/**
* Opens an {@link HttpURLConnection} with parameters.
*
* @param request
* @param listener
* @return an open connection
* @throws IOException
*/
private HttpURLConnection openConnection(WXRequest request, OnHttpListener listener) throws IOException {
URL url = new URL(request.url);
HttpURLConnection connection = createConnection(url);
connection.setConnectTimeout(request.timeoutMs);
connection.setReadTimeout(request.timeoutMs);
connection.setUseCaches(false);
connection.setDoInput(true);
if (request.paramMap != null) {
Set<String> keySets = request.paramMap.keySet();
for (String key : keySets) {
connection.addRequestProperty(key, request.paramMap.get(key));
}
}
if ("POST".equals(request.method)) {
connection.setRequestMethod("POST");
if (request.body != null) {
if (listener != null) {
listener.onHttpUploadProgress(0);
}
connection.setDoOutput(true);
DataOutputStream out = new DataOutputStream(connection.getOutputStream());
//TODO big stream will cause OOM; Progress callback is meaningless
out.write(request.body.getBytes());
out.close();
if (listener != null) {
listener.onHttpUploadProgress(100);
}
}
} else if (!TextUtils.isEmpty(request.method)) {
connection.setRequestMethod(request.method);
} else {
connection.setRequestMethod("GET");
}
return connection;
}
private final void synchronizeLTI1SiteMemberships(final Site site, final String membershipsId, final String membershipsUrl, final String oauth_consumer_key, boolean isEmailTrustedConsumer) {
// Lookup the secret
final String configPrefix = "basiclti.provider." + oauth_consumer_key + ".";
final String oauth_secret = serverConfigurationService.getString(configPrefix+ "secret", null);
if (oauth_secret == null) {
log.error("launch.key.notfound {}. This site's memberships will NOT be synchronised.", oauth_consumer_key);
return;
}
OAuthMessage om = new OAuthMessage("POST", membershipsUrl, null);
om.addParameter(OAuth.OAUTH_CONSUMER_KEY, oauth_consumer_key);
om.addParameter(OAuth.OAUTH_SIGNATURE_METHOD, OAuth.HMAC_SHA1);
om.addParameter(OAuth.OAUTH_VERSION, "1.0");
om.addParameter(OAuth.OAUTH_TIMESTAMP, new Long((new Date().getTime()) / 1000).toString());
om.addParameter(OAuth.OAUTH_NONCE, UUID.randomUUID().toString());
om.addParameter(BasicLTIConstants.LTI_MESSAGE_TYPE, "basic-lis-readmembershipsforcontext");
om.addParameter(BasicLTIConstants.LTI_VERSION, "LTI-1p0");
om.addParameter("id", membershipsId);
OAuthConsumer oc = new OAuthConsumer(null, oauth_consumer_key, oauth_secret, null);
try {
OAuthSignatureMethod osm = OAuthSignatureMethod.newMethod(OAuth.HMAC_SHA1, new OAuthAccessor(oc));
osm.sign(om);
URL url = new URL(membershipsUrl);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setDoOutput(true);
connection.setDoInput(true);
connection.setInstanceFollowRedirects(false);
connection.setRequestMethod("POST");
connection.setUseCaches (false);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(connection.getOutputStream()));
bw.write(OAuth.formEncode(om.getParameters()));
bw.flush();
bw.close();
processMembershipsResponse(connection, site, oauth_consumer_key, isEmailTrustedConsumer);
} catch (Exception e) {
log.warn("Problem synchronizing LTI1 memberships.", e);
}
}
/**
* <b>CREATE</b>
*
* curl -i -X PUT "http://<HOST>:<PORT>/webhdfs/v1/<PATH>?op=CREATE
* [&overwrite=<true|false>][&blocksize=<LONG>][&replication=<SHORT>]
* [&permission=<OCTAL>][&buffersize=<INT>]"
*
* @param path
* @param is
* @return
* @throws MalformedURLException
* @throws IOException
* @throws AuthenticationException
*/
public String createPOC(String path, InputStream is, HashMap<String, String> map)
throws MalformedURLException, IOException, AuthenticationException {
String resp = null;
ensureValidToken();
String redirectUrl = null;
HttpURLConnection conn = authenticatedURL
.openConnection(
new URL(new URL(httpfsUrl), MessageFormat.format(
"/webhdfs/v1/{0}?op=CREATE",
URLUtil.encodePath(path))), token);
conn.setRequestMethod("PUT");
conn.setInstanceFollowRedirects(false);
conn.connect();
logger.info("Location:" + conn.getHeaderField("Location"));
System.out.println("Location:" + conn.getHeaderField("Location"));
resp = result(conn, true);
if (conn.getResponseCode() == 307){
String str = conn.getHeaderField("Location");
if(str.startsWith("http://big1.big")){
redirectUrl = str.replaceAll("big1.big", map.get("big1.big"));
}else if(str.startsWith("http://big2.big")){
redirectUrl = str.replaceAll("big2.big", map.get("big2.big"));
}else if(str.startsWith("http://big3.big")){
redirectUrl = str.replaceAll("big3.big", map.get("big3.big"));
}else{
redirectUrl = conn.getHeaderField("Location");
}
}
conn.disconnect();
if (redirectUrl != null) {
conn = authenticatedURL.openConnection(new URL(redirectUrl), token);
conn.setRequestMethod("PUT");
conn.setDoOutput(true);
conn.setDoInput(true);
conn.setUseCaches(false);
conn.setRequestProperty("Content-Type", "application/octet-stream");
// conn.setRequestProperty("Transfer-Encoding", "chunked");
final int _SIZE = is.available();
conn.setRequestProperty("Content-Length", "" + _SIZE);
conn.setFixedLengthStreamingMode(_SIZE);
conn.connect();
OutputStream os = conn.getOutputStream();
copy(is, os);
// Util.copyStream(is, os);
is.close();
os.close();
resp = result(conn, false);
conn.disconnect();
}
return resp;
}
/**
* @param url 请求URL
* @param method 请求URL
* @param param json参数(post|put)
* @return
*/
public static String urlRequest(String url,String method,String param,String auth){
String result = null;
try {
HttpURLConnection connection = (HttpURLConnection)new URL(url).openConnection();
connection.setConnectTimeout(60*1000);
connection.setRequestMethod(method.toUpperCase());
if(auth!=null&&!"".equals(auth)){
String authorization = "Basic "+new String(Base64.encodeBase64(auth.getBytes()));
connection.setRequestProperty("Authorization", authorization);
}
if(param!=null&&!"".equals(param)){
connection.setDoInput(true);
connection.setDoOutput(true);
connection.connect();
DataOutputStream dos = new DataOutputStream(connection.getOutputStream());
dos.write(param.getBytes(Consts.UTF_8));
dos.flush();
dos.close();
}else{
connection.connect();
}
if(connection.getResponseCode()==HttpURLConnection.HTTP_OK){
InputStream in = connection.getInputStream();
ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] buff = new byte[1024];
int len = 0;
while((len=in.read(buff, 0, buff.length))>0){
out.write(buff, 0, len);
}
byte[] data = out.toByteArray();
in.close();
result = data!=null&&data.length>0?new String(data, Consts.UTF_8):null;
}else{
result = "{\"status\":"+connection.getResponseCode()+",\"msg\":\""+connection.getResponseMessage()+"\"}";
}
connection.disconnect();
}catch (Exception e) {
logger.error("--http request error !",e);
}
return result;
}
@Override
public StringBuffer downloadFileToStringBuilder(StringBuffer logsAggregate, URI uri) throws TransferException {
try {
logger.debug("Downloading file to String Buffer from {}", uri);
ArrayDeque<String> logLines = new ArrayDeque<>();
HttpURLConnection connection = (HttpURLConnection) uri.toURL().openConnection();
connection.setRequestMethod("GET");
connection.setDoOutput(true);
connection.setDoInput(true);
connection.setConnectTimeout(connectTimeout);
connection.setReadTimeout(readTimeout);
Consumer<String> removedLines = (removedLine) -> {
fullyDownloaded = false;
logger.debug("Dropped log line from URI {}: {}.", uri, removedLine);
};
try (InputStream inputStream = connection.getInputStream()) {
Charset charset = Charset.forName(ENCODING);
StringUtils.readStream(inputStream, charset, logLines, maxDownloadSize, removedLines);
}
logsAggregate.append("==== ").append(uri.toString()).append(" ====\n");
while (true) {
String line = logLines.pollFirst();
if (line == null) {
break;
}
logsAggregate.append(line + "\n");
}
if (logLines.size() > 0) {
logger.warn("Log buffer was not fully drained for URI: {}", uri);
}
if (logger.isTraceEnabled()) {
logger.trace("Downloaded log: {}.", logsAggregate);
}
return logsAggregate;
} catch (IOException e) {
throw new TransferException("Could not obtain log file: " + uri.toString(), e);
}
}