Java Proxy类代码示例

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
private DefaultRepositorySystemSession newRepositorySystemSession(RepositorySystem system, String localRepoPath) {
	DefaultRepositorySystemSession session = MavenRepositorySystemUtils.newSession();
	LocalRepository localRepo = new LocalRepository(localRepoPath);
	session.setLocalRepositoryManager(system.newLocalRepositoryManager(session, localRepo));
	session.setOffline(this.properties.isOffline());
	if (this.properties.getConnectTimeout() != null) {
		session.setConfigProperty(ConfigurationProperties.CONNECT_TIMEOUT, this.properties.getConnectTimeout());
	}
	if (this.properties.getRequestTimeout() != null) {
		session.setConfigProperty(ConfigurationProperties.REQUEST_TIMEOUT, this.properties.getRequestTimeout());
	}
	if (isProxyEnabled()) {
		DefaultProxySelector proxySelector = new DefaultProxySelector();
		Proxy proxy = new Proxy(this.properties.getProxy().getProtocol(),
				this.properties.getProxy().getHost(),
				this.properties.getProxy().getPort(),
				this.authentication);
		proxySelector.add(proxy, this.properties.getProxy().getNonProxyHosts());
		session.setProxySelector(proxySelector);
	}
	return session;
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
private List<RemoteRepository> initRemoteRepositories() {
    List<RemoteRepository> remoteRepositories = new ArrayList<RemoteRepository>();
    List<RemoteRepository.Builder> builders = new ArrayList<RemoteRepository.Builder>();

    List<RemoteRepository> pullRemoteRepo = this.mvnConsumerConfigurer.getPullRemoteRepo();
    for (RemoteRepository aPullRemoteRepository : pullRemoteRepo) {
        builders.add(new RemoteRepository.Builder(aPullRemoteRepository));
    }


    // Add this to support proxy configuration
    for (RemoteRepository.Builder builder : builders) {
        logger.debug("Processing builder {}",builder);
        if (mvnProxySelector != null) {
            logger.debug("Proxy selector {} found for builder {}",mvnProxySelector,builder);
            RemoteRepository remoteRepo = builder.build();
            Proxy proxy = mvnProxySelector.getProxy(remoteRepo);
            if (proxy != null) {
                logger.debug("[repo:{}] => setProxy({})", remoteRepo.getHost(), proxy.toString());
                builder.setProxy(proxy);
            }
        }
        remoteRepositories.add(builder.build());
    }
    return remoteRepositories;
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
public ProxySelector selectProxies() {
    DefaultProxySelector proxySelector = new DefaultProxySelector();
    String httpProxyHost = System.getProperty("http.proxyHost");
    if (httpProxyHost != null) {
        logger.debug("Setting same proxy for http and https");
        int proxyPort = -1;
        try {
            proxyPort = Integer.parseInt(System.getProperty("http.proxyPort"));
        } catch (NumberFormatException nfe) {
            throw new RuntimeException("Invalid (or null) http.proxyPort specified into system.properties");
        }
        String nonProxyHosts = System.getProperty("http.nonProxyHosts");
        nonProxyHosts = (nonProxyHosts != null ? nonProxyHosts : "");
        Proxy httpProxy = new Proxy("http", httpProxyHost, proxyPort, null);
        Proxy httpsProxy = new Proxy("https", httpProxyHost, proxyPort, null);

        proxySelector.add(httpProxy, nonProxyHosts);
        proxySelector.add(httpsProxy, nonProxyHosts);
        logger.debug("MvnRepo proxy set to {}:{}" + (nonProxyHosts != null ? " (nonProxyHosts:" + nonProxyHosts + ")" : ""), httpProxyHost, proxyPort);
    } else {
        logger.debug("No proxy set (http.proxyHost not defined).");

    }
    return proxySelector;
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
@Override
public Proxy getProxy(RemoteRepository repository) {
	for (ProxySelector selector : this.selectors) {
		Proxy proxy = selector.getProxy(repository);
		if (proxy != null) {
			return proxy;
		}
	}
	return null;
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
private void assertProxySelectorConfiguration(DefaultRepositorySystemSession session,
		RemoteRepository repository) {
	Proxy proxy = session.getProxySelector().getProxy(repository);
	repository = new RemoteRepository.Builder(repository).setProxy(proxy).build();
	AuthenticationContext authenticationContext = AuthenticationContext
			.forProxy(session, repository);
	assertThat(proxy.getHost()).isEqualTo("proxy.example.com");
	assertThat(authenticationContext.get(AuthenticationContext.USERNAME))
			.isEqualTo("proxyuser");
	assertThat(authenticationContext.get(AuthenticationContext.PASSWORD))
			.isEqualTo("somepassword");
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
protected Proxy createProxy(){
	for (ProxyConfig c : getProxies()){
		if (c.getActive().booleanValue()){
			return c.createProxy();
		}
	}
	return null;					
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
private RemoteRepository buildRemoteRepository(final String id, final String url, final Authentication auth,
                                               final ArtifactRepositoryPolicy releasesPolicy, final ArtifactRepositoryPolicy snapshotsPolicy) {
    RemoteRepository.Builder builder = new RemoteRepository.Builder(id, "default", url);
    if (auth != null
            && auth.getUsername() != null
            && auth.getPassword() != null) {
        builder.setAuthentication(new AuthenticationBuilder()
                                          .addUsername(auth.getUsername())
                                          .addPassword(auth.getPassword()).build());
    }

    builder.setSnapshotPolicy(new RepositoryPolicy(snapshotsPolicy.isEnabled(), snapshotsPolicy.getUpdatePolicy(), snapshotsPolicy.getChecksumPolicy()));
    builder.setReleasePolicy(new RepositoryPolicy(releasesPolicy.isEnabled(), releasesPolicy.getUpdatePolicy(), releasesPolicy.getChecksumPolicy()));

    RemoteRepository repository = builder.build();

    final RemoteRepository mirror = session.getMirrorSelector().getMirror(repository);

    if (mirror != null) {
        final org.eclipse.aether.repository.Authentication mirrorAuth = session.getAuthenticationSelector()
                .getAuthentication(mirror);
        RemoteRepository.Builder mirrorBuilder = new RemoteRepository.Builder(mirror)
                .setId(repository.getId())
                .setSnapshotPolicy(new RepositoryPolicy(snapshotsPolicy.isEnabled(), snapshotsPolicy.getUpdatePolicy(), snapshotsPolicy.getChecksumPolicy()))
                .setReleasePolicy(new RepositoryPolicy(releasesPolicy.isEnabled(), releasesPolicy.getUpdatePolicy(), releasesPolicy.getChecksumPolicy()));
        if (mirrorAuth != null) {
            mirrorBuilder.setAuthentication(mirrorAuth);
        }
        repository = mirrorBuilder.build();
    }

    Proxy proxy = session.getProxySelector().getProxy(repository);

    if (proxy != null) {
        repository = new RemoteRepository.Builder(repository).setProxy(proxy).build();
    }

    return repository;
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
private void assertProxySelectorConfiguration(DefaultRepositorySystemSession session,
		RemoteRepository repository) {
	Proxy proxy = session.getProxySelector().getProxy(repository);
	repository = new RemoteRepository.Builder(repository).setProxy(proxy).build();
	AuthenticationContext authenticationContext = AuthenticationContext
			.forProxy(session, repository);
	assertEquals("proxy.example.com", proxy.getHost());
	assertEquals("proxyuser",
			authenticationContext.get(AuthenticationContext.USERNAME));
	assertEquals("somepassword",
			authenticationContext.get(AuthenticationContext.PASSWORD));
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
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;
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
public Proxy createProxy(){
	return new Proxy(getProtocol(),getHost(),getPort());
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
@Override
public Proxy getProxy() {
	return proxy;
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
@Override
public void setProxy(Proxy proxy) {
	this.proxy = proxy;
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
@Override
public AetherClasspathResolver withProxy(Proxy proxy) {
	setProxy(proxy);
	return this;
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
public SoapUIMockRunner setProxy(String type, String host, int port,
		String username, String password) {

	Authentication auth = new AuthenticationBuilder().addUsername(username)
			.addPassword(password).build();

	resolver.setProxy(new Proxy(type, host, port, auth));

	return this;
}
 

import org.eclipse.aether.repository.Proxy; //导入依赖的package包/类
public Proxy getProxy();