Java HttpURLConnection.HTTP_MOVED_PERM属性代码示例

private static URLConnection checkRedirect(URLConnection conn, int timeout) throws IOException {
    if (conn instanceof HttpURLConnection) {
        conn.connect();
        int code = ((HttpURLConnection) conn).getResponseCode();
        if (code == HttpURLConnection.HTTP_MOVED_TEMP
                || code == HttpURLConnection.HTTP_MOVED_PERM) {
            // in case of redirection, try to obtain new URL
            String redirUrl = conn.getHeaderField("Location"); //NOI18N
            if (null != redirUrl && !redirUrl.isEmpty()) {
                //create connection to redirected url and substitute original conn
                URL redirectedUrl = new URL(redirUrl);
                URLConnection connRedir = redirectedUrl.openConnection();
                // XXX is this neede
                connRedir.setRequestProperty("User-Agent", "NetBeans"); // NOI18N
                connRedir.setConnectTimeout(timeout);
                connRedir.setReadTimeout(timeout);
                if (connRedir instanceof HttpsURLConnection) {
                    NetworkAccess.initSSL((HttpsURLConnection) connRedir);
                }
                return connRedir;
            }
        }
    }
    return conn;
}
 

private static URLConnection handleRedirect(URLConnection urlConnection, int retriesLeft) throws IOException
{
    if (retriesLeft == 0)
    {
        throw new IOException("too many redirects connecting to "+urlConnection.getURL().toString());
    }
    if (urlConnection instanceof HttpURLConnection)
    {
        HttpURLConnection conn = (HttpURLConnection) urlConnection;

        int status = conn.getResponseCode();
        if (status == HttpURLConnection.HTTP_MOVED_PERM || status == HttpURLConnection.HTTP_MOVED_TEMP || status == HttpURLConnection.HTTP_SEE_OTHER)
        {
            String newUrl = conn.getHeaderField("Location");
            return handleRedirect(new URL(newUrl).openConnection(), retriesLeft - 1);
        }
    }
    return urlConnection;
}
 

static boolean linkIsReview(String link)
{
    try
    {
        HttpURLConnection con = (HttpURLConnection) new URL(link).openConnection();
        HttpsURLConnection sslCon = (HttpsURLConnection) con;
        sslCon.setInstanceFollowRedirects(false);
        sslCon.connect();
        if(con.getResponseCode() == HttpURLConnection.HTTP_MOVED_PERM || con.getResponseCode() == HttpURLConnection.HTTP_MOVED_TEMP)
        {
            String newUrl = con.getHeaderField("Location");
            newUrl = "https://nl.trustpilot.com" + newUrl;
            con.disconnect();
            return true;
        }

    }
    catch (Exception ex)
    {
        System.out.println(ex);
    }
    return false;
}
 

/**
 * Returns true if this response can be stored to later serve another
 * request.
 */
public boolean isCacheable(RequestHeaders request) {
  // Always go to network for uncacheable response codes (RFC 2616, 13.4),
  // This implementation doesn't support caching partial content.
  int responseCode = headers.getResponseCode();
  if (responseCode != HttpURLConnection.HTTP_OK
      && responseCode != HttpURLConnection.HTTP_NOT_AUTHORITATIVE
      && responseCode != HttpURLConnection.HTTP_MULT_CHOICE
      && responseCode != HttpURLConnection.HTTP_MOVED_PERM
      && responseCode != HttpURLConnection.HTTP_GONE) {
    return false;
  }

  // Responses to authorized requests aren't cacheable unless they include
  // a 'public', 'must-revalidate' or 's-maxage' directive.
  if (request.hasAuthorization() && !isPublic && !mustRevalidate && sMaxAgeSeconds == -1) {
    return false;
  }

  if (noStore) {
    return false;
  }

  return true;
}
 

private static boolean isRedirect(int code) {
    return code == HttpURLConnection.HTTP_MOVED_PERM
            || code == HttpURLConnection.HTTP_MOVED_TEMP
            || code == HttpURLConnection.HTTP_SEE_OTHER
            || code == HttpURLConnection.HTTP_MULT_CHOICE
            || code == HTTP_TEMPORARY_REDIRECT
            || code == HTTP_PERMANENT_REDIRECT;
}
 

private static boolean isHttpRedirect(int responseCode) {
  switch (responseCode) {
    case HttpURLConnection.HTTP_MULT_CHOICE:
    case HttpURLConnection.HTTP_MOVED_PERM:
    case HttpURLConnection.HTTP_MOVED_TEMP:
    case HttpURLConnection.HTTP_SEE_OTHER:
    case HTTP_TEMPORARY_REDIRECT:
    case HTTP_PERMANENT_REDIRECT:
      return true;
    default:
      return false;
  }
}
 

public static String checkForRedirect(String url) {
	try {
		HttpURLConnection con = (HttpURLConnection) new URL( url ).openConnection();
		if (con.getResponseCode() == HttpURLConnection.HTTP_MOVED_PERM) {
			url = con.getHeaderField("Location");
		}
	} catch(IOException e) {
		e.printStackTrace();
	}
	return url;
}
 

public static URI unredirect(URI uri) throws IOException {
  if (!REDIRECTOR_DOMAINS.contains(uri.getHost())) {
    return uri;
  }
  URL url = uri.toURL();
  HttpURLConnection connection = safelyOpenConnection(url);
  connection.setInstanceFollowRedirects(false);
  connection.setDoInput(false);
  connection.setRequestMethod("HEAD");
  connection.setRequestProperty("User-Agent", "ZXing (Android)");
  try {
    int responseCode = safelyConnect(uri.toString(), connection);
    switch (responseCode) {
      case HttpURLConnection.HTTP_MULT_CHOICE:
      case HttpURLConnection.HTTP_MOVED_PERM:
      case HttpURLConnection.HTTP_MOVED_TEMP:
      case HttpURLConnection.HTTP_SEE_OTHER:
      case 307: // No constant for 307 Temporary Redirect ?
        String location = connection.getHeaderField("Location");
        if (location != null) {
          try {
            return new URI(location);
          } catch (URISyntaxException e) {
            // nevermind
          }
        }
    }
    return uri;
  } finally {
    connection.disconnect();
  }
}
 

public static URI unredirect(URI uri) throws IOException {
  if (!REDIRECTOR_DOMAINS.contains(uri.getHost())) {
    return uri;
  }
  URL url = uri.toURL();
  HttpURLConnection connection = safelyOpenConnection(url);
  connection.setInstanceFollowRedirects(false);
  connection.setDoInput(false);
  connection.setRequestMethod("HEAD");
  connection.setRequestProperty("User-Agent", "ZXing (Android)");
  try {
    int responseCode = safelyConnect(connection);
    switch (responseCode) {
      case HttpURLConnection.HTTP_MULT_CHOICE:
      case HttpURLConnection.HTTP_MOVED_PERM:
      case HttpURLConnection.HTTP_MOVED_TEMP:
      case HttpURLConnection.HTTP_SEE_OTHER:
      case 307: // No constant for 307 Temporary Redirect ?
        String location = connection.getHeaderField("Location");
        if (location != null) {
          try {
            return new URI(location);
          } catch (URISyntaxException e) {
            // nevermind
          }
        }
    }
    return uri;
  } finally {
    connection.disconnect();
  }
}
 

private static boolean isRedirection(int code) {
    return code == HttpURLConnection.HTTP_MOVED_PERM
            || code == HttpURLConnection.HTTP_MOVED_TEMP
            || code == HttpURLConnection.HTTP_SEE_OTHER
            || code == HttpURLConnection.HTTP_MULT_CHOICE
            || code == Constants.HTTP_TEMPORARY_REDIRECT
            || code == Constants.HTTP_PERMANENT_REDIRECT;
}
 

/**
 * Returns true if the status code implies the resource has moved
 * @param statusCode    the HTTP status code
 * @return              true if resource has moved
 */
private boolean hasMoved(int statusCode) {
    switch (statusCode) {
        case HttpURLConnection.HTTP_MOVED_TEMP: return true;
        case HttpURLConnection.HTTP_MOVED_PERM: return true;
        case HttpURLConnection.HTTP_SEE_OTHER:  return true;
        default:                                return false;
    }
}
 

/**
 * check whether redirect is configured
 * @param response
 * @return
 */
private boolean redirectConfigured( WebResponse response ) {
	boolean isAutoredirect=getClient().getClientProperties().isAutoRedirect();
	boolean hasLocation=response.getHeaderField( "Location" ) != null;
	int responseCode=response.getResponseCode();
	boolean result=isAutoredirect
  	&& responseCode >= HttpURLConnection.HTTP_MOVED_PERM
  	&& responseCode <= HttpURLConnection.HTTP_MOVED_TEMP
  	&& hasLocation;
  return result;
}
 

/**
 * this method intercepts redirect statusCode and calls {@link #onRedirect(int, String)} methods
 *  if fellowRedirects or followSslRedirects returns false.
 *  
 * this method called by okhttp'callback method ,as a hook method, should be
 * overrode by sub-class,and the sub-class should call super.Response(Call call,Response response)
 * 
 * @param call 		the call 
 * 
 * @param response  the response
 * 
 * @return return false if called {@link #onRedirect(int, String)} ,otherwise return true.
 * */
protected boolean onResponse(Call call, Response response) {
	if(null == okHttpClient){
		throw new NullPointerException("none okHttpClient attached with "+call);
	}
	boolean isFollowRedirects = okHttpClient.followRedirects()
								&&okHttpClient.followSslRedirects();
	System.out.println("isFollowRedirects->"+isFollowRedirects);
	final int statusCode = response.code();
	if ((statusCode == HttpURLConnection.HTTP_MOVED_TEMP 
		|| statusCode == HttpURLConnection.HTTP_MULT_CHOICE 
		|| statusCode == HttpURLConnection.HTTP_MOVED_PERM
		|| statusCode == HttpURLConnection.HTTP_SEE_OTHER)
		&&!isFollowRedirects) {
		String location = response.header("Location");
		System.out.println("header location:"+location);
		if(location == null || location.trim().length() == 0)
		{
			try {
				location = response.body().string();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		final String locationInfo = location;
		OkhttpUtil.getInstance().executeInMainThread(new Runnable() {

			public void run() {
				// TODO Auto-generated method stub
				onRedirect(statusCode, locationInfo);
			}
		});
		return false;
	}
	return true;
}
 

private static boolean isHttpRedirect(int responseCode) {
    switch (responseCode) {
        case HttpURLConnection.HTTP_MULT_CHOICE:
        case HttpURLConnection.HTTP_MOVED_PERM:
        case HttpURLConnection.HTTP_MOVED_TEMP:
        case HttpURLConnection.HTTP_SEE_OTHER:
        case HTTP_TEMPORARY_REDIRECT:
        case HTTP_PERMANENT_REDIRECT:
            return true;
        default:
            return false;
    }
}
 

public static String getFinalURL(String url) throws IOException {
    HttpURLConnection con = (HttpURLConnection) new URL(url).openConnection();
    con.setInstanceFollowRedirects(false);
    con.connect();
    con.getInputStream();

    if (con.getResponseCode() == HttpURLConnection.HTTP_MOVED_PERM || con.getResponseCode() == HttpURLConnection.HTTP_MOVED_TEMP) {
        String redirectUrl = con.getHeaderField("Location");
        return getFinalURL(redirectUrl);
    }
    return url;
}