Java Code Examples for java.net.Proxy.Type#HTTP

/**
 * 初始化HTTP代理服务器
 */
private void initHttpProxy() {
    // 初始化代理服务器
    if (httpProxyHost != null && httpProxyPort != null) {
        SocketAddress sa = new InetSocketAddress(httpProxyHost, httpProxyPort);
        proxy = new Proxy(Type.HTTP, sa);
        // 初始化代理服务器的用户验证
        if (httpProxyUsername != null && httpProxyPassword != null) {
            Authenticator.setDefault(new Authenticator() {

                @Override
                protected PasswordAuthentication getPasswordAuthentication() {
                    return new PasswordAuthentication(httpProxyUsername, httpProxyPassword.toCharArray());
                }
            });
        }

    }
}
 

/**
 * 初始化HTTP代理服务器
 */
private void initHttpProxy() {
    // 初始化代理服务器
    if (httpProxyHost != null && httpProxyPort != null) {
        SocketAddress sa = new InetSocketAddress(httpProxyHost, httpProxyPort);
        proxy = new Proxy(Type.HTTP, sa);
        // 初始化代理服务器的用户验证
        if (httpProxyUsername != null && httpProxyPassword != null) {
            Authenticator.setDefault(new Authenticator() {

                @Override
                protected PasswordAuthentication getPasswordAuthentication() {
                    return new PasswordAuthentication(httpProxyUsername, httpProxyPassword.toCharArray());
                }
            });
        }

    }
}
 

private Proxy getProxyFromProxyData(IProxyData proxyData) throws UnknownHostException {
	
	Type proxyType;
	if (IProxyData.HTTP_PROXY_TYPE.equals(proxyData.getType())) {
		proxyType = Type.HTTP;
	} else if (IProxyData.SOCKS_PROXY_TYPE.equals(proxyData.getType())) {
		proxyType = Type.SOCKS;
	} else if (IProxyData.HTTPS_PROXY_TYPE.equals(proxyData.getType())) {
		proxyType = Type.HTTP;
	} else {
		throw new IllegalArgumentException("Invalid proxy type " + proxyData.getType());
	}

	InetSocketAddress sockAddr = new InetSocketAddress(InetAddress.getByName(proxyData.getHost()), proxyData.getPort());
	Proxy proxy = new Proxy(proxyType, sockAddr);
	if (!Strings.isNullOrEmpty(proxyData.getUserId())) {
		Authenticator.setDefault(new ProxyAuthenticator(proxyData.getUserId(), proxyData.getPassword()));  
	}
	return proxy;
}
 

private Proxy getProxy(URI uri) {
  if (proxyService == null) {
    return Proxy.NO_PROXY;
  }
  IProxyData[] proxies = proxyService.select(uri);
  for (IProxyData proxyData : proxies) {
    switch (proxyData.getType()) {
      case IProxyData.HTTPS_PROXY_TYPE:
      case IProxyData.HTTP_PROXY_TYPE:
        return new Proxy(
            Type.HTTP, new InetSocketAddress(proxyData.getHost(), proxyData.getPort()));
      case IProxyData.SOCKS_PROXY_TYPE:
        return new Proxy(
            Type.SOCKS, new InetSocketAddress(proxyData.getHost(), proxyData.getPort()));
      default:
        logger.warning("Unknown proxy-data type: " + proxyData.getType()); //$NON-NLS-1$
        break;
    }
  }
  return Proxy.NO_PROXY;
}
 

@VisibleForTesting
public Proxy createProxy(URI uri) {
  Preconditions.checkNotNull(uri, "uri is null");
  Preconditions.checkArgument(!"http".equals(uri.getScheme()), "http is not a supported schema");

  IProxyService proxyServiceCopy = proxyService;
  if (proxyServiceCopy == null) {
    return Proxy.NO_PROXY;
  }

  IProxyData[] proxyDataForUri = proxyServiceCopy.select(uri);
  for (final IProxyData iProxyData : proxyDataForUri) {
    switch (iProxyData.getType()) {
      case IProxyData.HTTPS_PROXY_TYPE:
        return new Proxy(Type.HTTP, new InetSocketAddress(iProxyData.getHost(),
                                                          iProxyData.getPort()));
      case IProxyData.SOCKS_PROXY_TYPE:
        return new Proxy(Type.SOCKS, new InetSocketAddress(iProxyData.getHost(),
                                                           iProxyData.getPort()));
      default:
        logger.warning("Unsupported proxy type: " + iProxyData.getType());
        break;
    }
  }
  return Proxy.NO_PROXY;
}
 

/**
 * Test that the proxy is being used, but don't check the credentials. Credentials can still be
 * used, but they must be set using the appropriate system properties and testing that is not what
 * we are looking to do here.
 */
@Test
public void canCreateWithImplicitOrNoCredentials() throws Exception {
  Proxied proxied = new Proxied(
      TrustingSSLSocketFactory.get(), null,
      new Proxy(Type.HTTP, proxyAddress));
  assertThat(proxied).isNotNull();
  assertThat(proxied.getCredentials()).isNullOrEmpty();

  /* verify that the proxy */
  HttpURLConnection connection = proxied.getConnection(new URL("http://www.example.com"));
  assertThat(connection).isNotNull().isInstanceOf(HttpURLConnection.class);
}
 

/**
 * 
 * Sets the proxy host and port. This will be implicitly called if
 * "proxy.host" and "proxy.port" properties are given in properties file
 * 
 * @param host
 *            proxy host
 * @param port
 *            proxy port
 */
public static void setProxyConfig(final String host, final int port) {
	if (host != null) {
		int proxyPort = port;
		if (proxyPort < 0) {
			proxyPort = 0;
		}
		LOG.debug("Setting proxy - Host : " + host + "   port : " + port);
		proxyObj = new Proxy(Type.HTTP, new InetSocketAddress(host, port));
	}
}
 

@Before
public void setUp() {
    Proxy proxy = new Proxy(Type.HTTP, new InetSocketAddress(PROXY_SERVER_HOST, PROXY_SERVER_PORT));

    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    requestFactory.setProxy(proxy);

    restTemplate = new RestTemplate(requestFactory);
}
 

public Proxy toProxy() {
	if (hasValidProxySettings()) {
		switch (type) {
		case HTTP:
		case HTTPS:
			return new Proxy(Type.HTTP, new InetSocketAddress(host, port));
		case SOCKS:
			return new Proxy(Type.SOCKS, new InetSocketAddress(host, port));
		}
	}

	return null;
}
 

/**
 * @return the proxy settings
 */
public Proxy getProxy() {        
    LeoObject proxy = this.config.get("master_server", "proxy_settings");
    if(LeoObject.isTrue(proxy)) {
        Proxy p = new Proxy(Type.HTTP, new InetSocketAddress(this.config.getString("master_server", "proxy_settings", "address"), 
                                                             this.config.getInt(88, "master_server", "proxy_settings", "port")));
        
        return (p);
    }
    
    return Proxy.NO_PROXY;
}
 

private static Proxy getProxy ( final String url )
{
    final ProxySelector ps = ProxySelector.getDefault ();
    if ( ps == null )
    {
        logger.debug ( "No proxy selector found" );
        return null;
    }

    final List<java.net.Proxy> proxies = ps.select ( URI.create ( url ) );
    for ( final java.net.Proxy proxy : proxies )
    {
        if ( proxy.type () != Type.HTTP )
        {
            logger.debug ( "Unsupported proxy type: {}", proxy.type () );
            continue;
        }

        final SocketAddress addr = proxy.address ();
        logger.debug ( "Proxy address: {}", addr );

        if ( ! ( addr instanceof InetSocketAddress ) )
        {
            logger.debug ( "Unsupported proxy address type: {}", addr.getClass () );
            continue;
        }

        final InetSocketAddress inetAddr = (InetSocketAddress)addr;

        return new Proxy ( Proxy.TYPE_HTTP, inetAddr.getHostString (), inetAddr.getPort () );
    }

    logger.debug ( "No proxy found" );
    return null;
}
 

@Test
public void testConstructorWithProxyAndTimeouts() throws MalformedURLException, IOException {
  Proxy proxy =
      new Proxy(Type.HTTP,
                new InetSocketAddress(proxyServer.getHostname(), proxyServer.getPort()));
  HttpURLConnection connection =
      new TimeoutAwareConnectionFactory(proxy, 1764, 3528)
          .openConnection(new URL(NONEXISTENTDOMAIN));
  connectReadAndDisconnect(connection);
  assertThat(connection.getConnectTimeout(), is(1764));
  assertThat(connection.getReadTimeout(), is(3528));
}
 

@Test
public void testConstructorWithProxy() throws MalformedURLException, IOException {
  Proxy proxy =
      new Proxy(Type.HTTP,
                new InetSocketAddress(proxyServer.getHostname(), proxyServer.getPort()));
  HttpURLConnection connection =
      new TimeoutAwareConnectionFactory(proxy).openConnection(new URL(NONEXISTENTDOMAIN));
  connectReadAndDisconnect(connection);
}
 

private static HttpURLConnection getConnection(URL url, String method, String ctype,
                                               String proxyHost, int proxyPort) throws IOException {
    Proxy proxy = new Proxy(Type.HTTP, new InetSocketAddress(proxyHost, proxyPort));
    return getConnection(url, method, ctype, proxy);
}
 

@Test
public void canCreateWithExplicitCredentials() throws Exception {
  Proxied proxied = new Proxied(
      TrustingSSLSocketFactory.get(), null,
      new Proxy(Type.HTTP, proxyAddress), "user", "password");
  assertThat(proxied).isNotNull();
  assertThat(proxied.getCredentials()).isNotBlank();

  HttpURLConnection connection = proxied.getConnection(new URL("http://www.example.com"));
  assertThat(connection).isNotNull().isInstanceOf(HttpURLConnection.class);
}
 

private HttpURLConnection openConnection ( final URL url ) throws IOException
{
    final String host = this.properties.getProperty ( "local.proxy.host" );
    final String port = this.properties.getProperty ( "local.proxy.port" );

    if ( host != null && port != null && !host.isEmpty () && !port.isEmpty () )
    {
        final Proxy proxy = new Proxy ( Type.HTTP, new InetSocketAddress ( host, Integer.parseInt ( port ) ) );
        return (HttpURLConnection)url.openConnection ( proxy );
    }
    else
    {
        return (HttpURLConnection)url.openConnection ();
    }
}
 

private Proxy createProxy() {
    return new Proxy(Type.HTTP, new InetSocketAddress(this.httpProxyHost, this.httpProxyPort));
}
 

private Socket open(Proxy proxy) throws IOException {
	try {
		if (proxy.type() != Type.DIRECT) {
			SocketAddress var3 = proxy.address();
			if (var3 instanceof InetSocketAddress) {
				InetSocketAddress var4 = (InetSocketAddress) var3;
				if (proxy.type() == Type.HTTP) {
					String var16 = null;

					try {
						Class<?> var6 = Class.forName("sun.net.www.protocol.http.AuthenticationInfo");
						Method var7 = var6.getDeclaredMethod("getProxyAuth",
							String.class, Integer.TYPE);
						var7.setAccessible(true);
						Object var8 = var7.invoke(null,
							var4.getHostName(), valueOf(var4.getPort()));
						if (null != var8) {
							Method var9 = var6.getDeclaredMethod("supportsPreemptiveAuthorization");
							var9.setAccessible(true);
							if ((Boolean) var9.invoke(var8, new Object[0])) {
								Method var10 = var6.getDeclaredMethod("getHeaderName");
								var10.setAccessible(true);
								Method var11 = var6.getDeclaredMethod("getHeaderValue",
									URL.class, String.class);
								var11.setAccessible(true);
								String var12 = (String) var10.invoke(var8, new Object[0]);
								String var13 = (String) var11.invoke(var8,
									new Object[]{new URL("https://" + this.socketHost + "/"), "https"});
								var16 = var12 + ": " + var13;
							}
						}
					} catch (Exception ignored) {
					}

					return this.openConnect(var4.getPort(), 1514, var16, var4.getHostName());
				} else if (proxy.type() != Type.SOCKS) {
					return null;
				} else {
					Socket var5 = new Socket(proxy);
					var5.connect(new InetSocketAddress(this.socketHost, this.socketPort));
					return var5;
				}
			} else {
				return null;
			}
		} else {
			return this.openRaw();
		}
	} catch (RuntimeException var15) {
		throw GenUtil.makeThrowable(var15,
			"gb.F(" + (proxy != null ? "{...}" : "null") + ',' + "dummy" + ')');
	}
}
 

public static HttpURLConnection getConnection(URL url, String method, String ctype,
                                              String proxyHost, int proxyPort) throws IOException {
    Proxy proxy = new Proxy(Type.HTTP, new InetSocketAddress(proxyHost, proxyPort));
    return getConnection(url, method, ctype, proxy);
}
 

@OnScheduled
public void setUpClient(final ProcessContext context) throws IOException {
    okHttpClientAtomicReference.set(null);

    OkHttpClient okHttpClient = new OkHttpClient();

    // Add a proxy if set
    final String proxyHost = context.getProperty(PROP_PROXY_HOST).getValue();
    final Integer proxyPort = context.getProperty(PROP_PROXY_PORT).asInteger();
    if (proxyHost != null && proxyPort != null) {
        final Proxy proxy = new Proxy(Type.HTTP, new InetSocketAddress(proxyHost, proxyPort));
        okHttpClient.setProxy(proxy);
    }

    // Set timeouts
    okHttpClient.setConnectTimeout((context.getProperty(PROP_CONNECT_TIMEOUT).asTimePeriod(TimeUnit.MILLISECONDS).intValue()), TimeUnit.MILLISECONDS);
    okHttpClient.setReadTimeout(context.getProperty(PROP_READ_TIMEOUT).asTimePeriod(TimeUnit.MILLISECONDS).intValue(), TimeUnit.MILLISECONDS);

    // Set whether to follow redirects
    okHttpClient.setFollowRedirects(context.getProperty(PROP_FOLLOW_REDIRECTS).asBoolean());

    final SSLContextService sslService = context.getProperty(PROP_SSL_CONTEXT_SERVICE).asControllerService(SSLContextService.class);
    final SSLContext sslContext = sslService == null ? null : sslService.createSSLContext(ClientAuth.NONE);

    // check if the ssl context is set and add the factory if so
    if (sslContext != null) {
        okHttpClient.setSslSocketFactory(sslContext.getSocketFactory());
    }

    // check the trusted hostname property and override the HostnameVerifier
    String trustedHostname = trimToEmpty(context.getProperty(PROP_TRUSTED_HOSTNAME).getValue());
    if (!trustedHostname.isEmpty()) {
        okHttpClient.setHostnameVerifier(new OverrideHostnameVerifier(trustedHostname, okHttpClient.getHostnameVerifier()));
    }

    setAuthenticator(okHttpClient, context);

    useChunked = context.getProperty(PROP_USE_CHUNKED_ENCODING).asBoolean();

    okHttpClientAtomicReference.set(okHttpClient);
}