import com.ning.http.client.Realm.AuthScheme; //导入依赖的package包/类
public URLCheckerService()
{
	Builder bc = new AsyncHttpClientConfig.Builder();
	bc.setAllowPoolingConnections(false); // Avoid keep-alive
	bc.setCompressionEnforced(true);
	bc.setUseProxyProperties(true);
	bc.setFollowRedirect(true);
	bc.setMaxConnectionsPerHost(2);
	bc.setMaxConnections(200);
	bc.setMaxRedirects(25);
	bc.setUserAgent("Mozilla/5.0 (compatible; equellaurlbot/1.0; +http://support.equella.com/)");

	// These are actually the defaults, but let's specify in case they
	// change
	bc.setConnectTimeout(60000);
	bc.setRequestTimeout(60000);
	// ^^ note the massive request timeout, this not a per-request timeout,
	// it's the whole redirection round trip

	// Just because a URL uses a self-signed certificate doesn't mean it's
	// not a working URL. We also don't care about MITM attacks since we're
	// just checking the URL.
	bc.setSSLContext(BlindSSLSocketFactory.createBlindSSLContext());

	// Configure a fake authentication in case some the URLs are using it.
	// http://jira.pearsoncmg.com/jira/browse/EQ-411
	Realm realm = new Realm.RealmBuilder().setPrincipal("").setPassword("").setUsePreemptiveAuth(true)
		.setScheme(AuthScheme.BASIC).build();
	bc.setRealm(realm);

	client = new AsyncHttpClient(bc.build());
}
 

import com.ning.http.client.Realm.AuthScheme; //导入依赖的package包/类
private WSRequest auth(String username, String password, AuthScheme scheme) {
    this.setRealm((new RealmBuilder())
            .setScheme(scheme)
            .setPrincipal(username)
            .setPassword(password)
            .setUsePreemptiveAuth(true)
            .build());
    return this;
}
 

import com.ning.http.client.Realm.AuthScheme; //导入依赖的package包/类
/**
 * Sets the authentication header for the current request using BASIC authentication.
 *
 * @param username
 * @param password
 */
public WSRequestHolder setAuth(String username, String password) {
    this.username = username;
    this.password = password;
    this.scheme = AuthScheme.BASIC;
    return this;
}
 

import com.ning.http.client.Realm.AuthScheme; //导入依赖的package包/类
private Realm createRealm() {
	Realm.RealmBuilder builder = new Realm.RealmBuilder();
	builder.setPrincipal(xbmc.getUsername());
	builder.setPassword(xbmc.getPassword());
	builder.setUsePreemptiveAuth(true);
	builder.setScheme(AuthScheme.BASIC);
	return builder.build();
}
 

import com.ning.http.client.Realm.AuthScheme; //导入依赖的package包/类
private BoundRequestBuilder prepare(BoundRequestBuilder builder) {
    if (this.username != null && this.password != null && this.scheme != null) {
        AuthScheme authScheme;
        switch (this.scheme) {
        case DIGEST: authScheme = AuthScheme.DIGEST; break;
        case NTLM: authScheme = AuthScheme.NTLM; break;
        case KERBEROS: authScheme = AuthScheme.KERBEROS; break;
        case SPNEGO: authScheme = AuthScheme.SPNEGO; break;
        case BASIC: authScheme = AuthScheme.BASIC; break;
        default: throw new RuntimeException("Scheme " + this.scheme + " not supported by the UrlFetch WS backend.");
        }
        builder.setRealm(
                (new RealmBuilder())
                .setScheme(authScheme)
                .setPrincipal(this.username)
                .setPassword(this.password)
                .setUsePreemptiveAuth(true)
                .build()
        );
    }
    for (String key: this.headers.keySet()) {
        builder.addHeader(key, headers.get(key));
    }
    builder.setFollowRedirects(this.followRedirects);
    PerRequestConfig perRequestConfig = new PerRequestConfig();
    perRequestConfig.setRequestTimeoutInMs(this.timeout * 1000);
    builder.setPerRequestConfig(perRequestConfig);
    return builder;
}
 

import com.ning.http.client.Realm.AuthScheme; //导入依赖的package包/类
private Realm createRealm() {
    Realm.RealmBuilder builder = new Realm.RealmBuilder();
    builder.setPrincipal(xbmc.getUsername());
    builder.setPassword(xbmc.getPassword());
    builder.setUsePreemptiveAuth(true);
    builder.setScheme(AuthScheme.BASIC);
    return builder.build();
}
 

import com.ning.http.client.Realm.AuthScheme; //导入依赖的package包/类
/**
 * @return the auth scheme, null if not an authenticated request
 */
public AuthScheme getScheme() {
    return this.scheme;
}
 

import com.ning.http.client.Realm.AuthScheme; //导入依赖的package包/类
public static Promise<Result> exchangeCodeForToken(String code) {
    String clientId = Play.application().configuration()
            .getString("audienceManager.clientId");
    String clientSecret = Play.application().configuration()
            .getString("audienceManager.clientSecret");
    String tokenUrl = Play.application().configuration()
            .getString("audienceManager.tokenUrl");

    // Sets the Authorization header to Basic
    // Base64Encoded(clientId:clientSecret) (includes colon)
    Promise<Result> promiseResult = WS
            .url(tokenUrl)
            .setAuth(clientId, clientSecret, AuthScheme.BASIC)
            .setContentType("application/x-www-form-urlencoded")
            .setHeader("Accept", "application/json")
            .post(String.format(TOKEN_TEMPLATE, clientId, clientSecret,
                    code)).map(new Function<Response, Result>() {

                @Override
                public Result apply(Response response) throws Throwable {
                    if (response.getStatus() == 200) {
                        AudienceManagerAuthentication aamAuth = new AudienceManagerAuthentication();
                        JsonNode responseJson = response.asJson();
                        aamAuth.accessToken = responseJson.get(
                                "access_token").asText();
                        aamAuth.refreshToken = responseJson.get(
                                "refresh_token").asText();
                        aamAuth.email = Application.getLoggedInUser().email;
                        AudienceManagerAuthentication.create(aamAuth);
                        Logger.info(String
                                .format("Got access token %s and refresh token %s for %s",
                                        aamAuth.accessToken,
                                        aamAuth.refreshToken, aamAuth.email));
                    } else {
                        Logger.error(String.format(
                                "Eror getting tokens for %s:\n %d\n %s",
                                Application.getLoggedInUser(),
                                response.getStatus(), response.getBody()));
                    }
                    return redirect(routes.Application.index());
                }

            });

    return promiseResult;
}