Java HttpURLConnection.HTTP_MOVED_TEMP属性代码示例

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;
}
 

private static boolean testHttpConnection(URL url, Proxy proxy) throws IOException{
    boolean result = false;
    
    HttpURLConnection httpConnection = (HttpURLConnection) url.openConnection(proxy);
    // Timeout shorten to 5s
    httpConnection.setConnectTimeout(5000);
    httpConnection.connect();

    if (httpConnection.getResponseCode() == HttpURLConnection.HTTP_OK || 
            httpConnection.getResponseCode() == HttpURLConnection.HTTP_MOVED_TEMP) {
        result = true;
    }

    httpConnection.disconnect();
    
    return result;
}
 

private static CharSequence downloadViaHttp(String uri, String contentTypes, int maxChars) throws IOException {
    int redirects = 0;
    while (redirects < 5) {
        URL url = new URL(uri);
        HttpURLConnection connection = safelyOpenConnection(url);
        connection.setInstanceFollowRedirects(true); // Won't work HTTP -> HTTPS or vice versa
        connection.setRequestProperty("Accept", contentTypes);
        connection.setRequestProperty("Accept-Charset", "utf-8,*");
        connection.setRequestProperty("User-Agent", "ZXing (Android)");
        try {
            int responseCode = safelyConnect(connection);
            switch (responseCode) {
                case HttpURLConnection.HTTP_OK:
                    return consume(connection, maxChars);
                case HttpURLConnection.HTTP_MOVED_TEMP:
                    String location = connection.getHeaderField("Location");
                    if (location != null) {
                        uri = location;
                        redirects++;
                        continue;
                    }
                    throw new IOException("No Location");
                default:
                    throw new IOException("Bad HTTP response: " + responseCode);
            }
        } finally {
            connection.disconnect();
        }
    }
    throw new IOException("Too many redirects");
}
 

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;
}
 

/**
 * 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;
    }
}
 

private static CharSequence downloadViaHttp(String uri, String contentTypes, int maxChars) throws IOException {
  int redirects = 0;
  while (redirects < 5) {
    URL url = new URL(uri);
    HttpURLConnection connection = safelyOpenConnection(url);
    connection.setInstanceFollowRedirects(true); // Won't work HTTP -> HTTPS or vice versa
    connection.setRequestProperty("Accept", contentTypes);
    connection.setRequestProperty("Accept-Charset", "utf-8,*");
    connection.setRequestProperty("User-Agent", "ZXing (Android)");
    try {
      int responseCode = safelyConnect(uri, connection);
      switch (responseCode) {
        case HttpURLConnection.HTTP_OK:
          return consume(connection, maxChars);
        case HttpURLConnection.HTTP_MOVED_TEMP:
          String location = connection.getHeaderField("Location");
          if (location != null) {
            uri = location;
            redirects++;
            continue;
          }
          throw new IOException("No Location");
        default:
          throw new IOException("Bad HTTP response: " + responseCode);
      }
    } finally {
      connection.disconnect();
    }
  }
  throw new IOException("Too many redirects");
}
 

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();
  }
}
 

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;
}
 

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;
}
 

@Override
public void handle(HttpExchange exchange) throws IOException {
  Map<String, String> queryParameters = getQueryParameters(exchange);
  String statusParam = queryParameters.get("status");
  int statusCode =
      (statusParam != null) ? Integer.parseInt(statusParam) : HttpURLConnection.HTTP_OK;

  String requestBody = streamToString(exchange.getRequestBody());

  String body = exchange.getRequestURI().toString();
  body += "\n";
  body += "\n";
  body += requestBody;

  byte[] response = body.getBytes();
  if (statusCode == HttpURLConnection.HTTP_MOVED_TEMP) {
    String redirectLocation = queryParameters.get("rd");
    if (redirectLocation == null) {
      statusCode = HttpURLConnection.HTTP_BAD_REQUEST;
    } else {
      exchange.getResponseHeaders().add("Location", redirectLocation);
    }
  }
  exchange.sendResponseHeaders(statusCode, response.length);
  OutputStream outputStream = exchange.getResponseBody();
  outputStream.write(response);
  outputStream.close();
  exchange.close();
}
 

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();
    }
}