import org.apache.jena.atlas.web.auth.HttpAuthenticator; //导入依赖的package包/类
/**
 * Prepares an authenticator that may use simple authentication
 * 
 * @param username
 *            User name
 * @param password
 *            Password
 * @param preemptive
 *            Preemptive auth?
 * @param endpoints
 *            Endpoints to configure authentication for
 * @return Authenticator or null if insufficient information to authenticate
 */
public static HttpAuthenticator prepareAuthentication(String username, String password, boolean preemptive, String... endpoints) {
    if (username != null && password != null) {
        try {
            Map<URI, Pair<String, char[]>> logins = new HashMap<URI, Pair<String, char[]>>();
            for (String endpoint : endpoints) {
                if (endpoint == null)
                    continue;
                logins.put(new URI(endpoint), Pair.create(username, password.toCharArray()));
            }

            HttpAuthenticator authenticator = new ScopedAuthenticator(logins);
            if (preemptive) {
                authenticator = new PreemptiveBasicAuthenticator(authenticator);
            }
            return authenticator;
        } catch (URISyntaxException e) {
            throw new IllegalArgumentException("Invalid Endpoint URL, unable to configure authentication: " + e.getMessage(),
                    e);
        }
    }
    return null;
}
 

import org.apache.jena.atlas.web.auth.HttpAuthenticator; //导入依赖的package包/类
public static ArrayList<Statement> readTriplesFromKs(String subjectUri, String sparqlQuery){

        ArrayList<Statement> triples = new ArrayList<Statement>();
        HttpAuthenticator authenticator = new SimpleAuthenticator(user, pass.toCharArray());
        try {
            qCount++;
            QueryExecution x = QueryExecutionFactory.sparqlService(serviceEndpoint, sparqlQuery, authenticator);
            ResultSet resultset = x.execSelect();
            while (resultset.hasNext()) {
                QuerySolution solution = resultset.nextSolution();
                String relString = solution.get("predicate").toString();
                RDFNode obj = solution.get("object");
                Model model = ModelFactory.createDefaultModel();
                Resource subj = model.createResource(subjectUri);
                Statement s = createStatement(subj, ResourceFactory.createProperty(relString), obj);
                triples.add(s);
            }
        } catch (Exception e) {
            //e.printStackTrace();
        }
        return triples;
    }
 

import org.apache.jena.atlas.web.auth.HttpAuthenticator; //导入依赖的package包/类
public static ArrayList<String> readEventIdsFromKs(String sparqlQuery)throws Exception {
    ArrayList<String> eventIds = new ArrayList<String>();
    //System.out.println("serviceEndpoint = " + serviceEndpoint);
    //System.out.println("sparqlQuery = " + sparqlQuery);
    //System.out.println("user = " + user);
    //System.out.println("pass = " + pass);
    HttpAuthenticator authenticator = new SimpleAuthenticator(user, pass.toCharArray());

    QueryExecution x = QueryExecutionFactory.sparqlService(serviceEndpoint, sparqlQuery, authenticator);
    ResultSet resultset = x.execSelect();
    while (resultset.hasNext()) {
        QuerySolution solution = resultset.nextSolution();
        //System.out.println("solution.toString() = " + solution.toString());
        //( ?event = <http://www.newsreader-project.eu/data/Dasym-Pilot/425819_relink_dominant.naf#ev24> )
        String currentEvent = solution.get("event").toString();
        //System.out.println("currentEvent = " + currentEvent);
        //http://www.newsreader-project.eu/data/Dasym-Pilot/425819_relink_dominant.naf#ev24
        if (!eventIds.contains(currentEvent)) {
            eventIds.add(currentEvent);
        }
    }
    return eventIds;
}
 

import org.apache.jena.atlas.web.auth.HttpAuthenticator; //导入依赖的package包/类
private static void inferIdentityRelations(String sparqlQuery, boolean matchILI, boolean matchLemma, boolean matchMultiple, int iliSize, Node eventId, DatasetGraph g) {
    if (matchILI || matchLemma) {
        sparqlQuery += "GROUP BY ?ev";
    }
    HttpAuthenticator authenticator = new SimpleAuthenticator(user, pass.toCharArray());
    QueryExecution x = QueryExecutionFactory.sparqlService(serviceEndpoint, sparqlQuery, authenticator);
    ResultSet resultset = x.execSelect();
    int threshold;
    while (resultset.hasNext()) {
        QuerySolution solution = resultset.nextSolution();
        if (matchILI || matchLemma) {
            if (matchILI)
                threshold = conceptMatchThreshold;
            else
                threshold=phraseMatchThreshold;

            if (matchMultiple) {
                //System.out.println(solution);
                if (checkIliLemmaThreshold(iliSize, solution.get("conceptcount").asLiteral().getInt(), solution.get("myconceptcount").asLiteral().getInt(), threshold)) {
                    insertIdentity(g, eventId, solution.get("ev").asNode());
                }
            } else {
                if (checkIliLemmaThreshold(1, solution.get("conceptcount").asLiteral().getInt(), 1, threshold)) {
                    insertIdentity(g, eventId, solution.get("ev").asNode());
                }
            }
        } else {
            insertIdentity(g, eventId, solution.get("ev").asNode());
        }
    }
}
 

import org.apache.jena.atlas.web.auth.HttpAuthenticator; //导入依赖的package包/类
private static ArrayList<Node> inferMultitimesIdentityRelations (String sparqlQuery, boolean matchILI, boolean matchLemma, boolean matchMultiple, int iliSize, String eventId) {
    if (matchILI || matchLemma) {
        sparqlQuery += "GROUP BY ?ev";
    }
    HttpAuthenticator authenticator = new SimpleAuthenticator(user, pass.toCharArray());
    QueryExecution x = QueryExecutionFactory.sparqlService(serviceEndpoint, sparqlQuery, authenticator);
    ResultSet resultset = x.execSelect();
    int threshold;
    ArrayList<Node> rslt = new ArrayList<Node>();
    while (resultset.hasNext()) {
        QuerySolution solution = resultset.nextSolution();
        if (matchILI || matchLemma) {
            if (matchILI)
                threshold = conceptMatchThreshold;
            else
                threshold=phraseMatchThreshold;

            if (matchMultiple) {
                //System.out.println(solution);
                if (checkIliLemmaThreshold(iliSize, solution.get("conceptcount").asLiteral().getInt(), solution.get("myconceptcount").asLiteral().getInt(), threshold)) {
                    rslt.add(solution.get("ev").asNode());
                }
            } else {
                if (checkIliLemmaThreshold(1, solution.get("conceptcount").asLiteral().getInt(), 1, threshold)) {
                    rslt.add(solution.get("ev").asNode());
                }
            }
        } else {
            rslt.add(solution.get("ev").asNode());
        }
    }
    return rslt;
}
 

import org.apache.jena.atlas.web.auth.HttpAuthenticator; //导入依赖的package包/类
/**
 * Prepares an authenticator that may use simple/form based authentication
 * 
 * @param username
 *            User name
 * @param password
 *            Password
 * @param preemptive
 *            Preemptive auth?
 * @param formUrl
 *            Form login URL
 * @param formUserField
 *            Form user field
 * @param formPwdField
 *            Form password field
 * @param endpoints
 *            Endpoints to configure authentication for
 * @return Authenticator or null if insufficient information to authenticate
 */
public static HttpAuthenticator prepareAuthenticator(String username, String password, boolean preemptive, String formUrl,
        String formUserField, String formPwdField, String... endpoints) {
    if (username != null && password != null) {
        if (formUrl != null) {
            // Configure forms auth
            if (formUserField == null)
                formUserField = ApacheModAuthFormLogin.USER_FIELD;
            if (formPwdField == null)
                formPwdField = ApacheModAuthFormLogin.PASSWORD_FIELD;

            FormLogin login = new FormLogin(formUrl, formUserField, formPwdField, username, password.toCharArray());
            try {
                Map<URI, FormLogin> logins = new HashMap<URI, FormLogin>();
                for (String endpoint : endpoints) {
                    if (endpoint == null)
                        continue;
                    logins.put(new URI(endpoint), login);
                }
                return new FormsAuthenticator(logins);
            } catch (URISyntaxException e) {
                throw new IllegalArgumentException("Invalid Endpoint URL, unable to configure form based authentication: "
                        + e.getMessage(), e);
            }
        } else {
            // Use standard HTTP authentication
            return prepareAuthentication(username, password, preemptive, endpoints);
        }
    }

    // Insufficient options to configure authentication
    return null;
}
 

import org.apache.jena.atlas.web.auth.HttpAuthenticator; //导入依赖的package包/类
@Override
public void apply(AbstractHttpClient client, HttpContext httpContext, URI target) {
    // Pick and apply an authenticator at random
    int id = this.rand.nextInt(this.authenticators.size());

    HttpAuthenticator authenticator = this.authenticators.get(id);
    if (authenticator == null) {
        logger.info("Picked authenticator " + id + " which does no authentication");
        return;
    }
    logger.info("Picked authenticator " + id + " which is " + authenticator.toString());
    authenticator.apply(client, httpContext, target);
}
 

import org.apache.jena.atlas.web.auth.HttpAuthenticator; //导入依赖的package包/类
@Override
public HttpAuthenticator getAuthenticator() {
    return this.authenticator;
}
 

import org.apache.jena.atlas.web.auth.HttpAuthenticator; //导入依赖的package包/类
@Override
public void setAuthenticator(HttpAuthenticator authenticator) {
    this.authenticator = authenticator;
}
 

import org.apache.jena.atlas.web.auth.HttpAuthenticator; //导入依赖的package包/类
@Override
public void invalidate() {
    for (HttpAuthenticator authenticator : this.authenticators) {
        authenticator.invalidate();
    }
}
 

import org.apache.jena.atlas.web.auth.HttpAuthenticator; //导入依赖的package包/类
/**
 * Gets the HTTP authenticator in use
 * 
 * @return HTTP authenticator
 */
public abstract HttpAuthenticator getAuthenticator();
 

import org.apache.jena.atlas.web.auth.HttpAuthenticator; //导入依赖的package包/类
/**
 * Sets the HTTP authenticator used
 * 
 * @param authenticator
 *            HTTP authenticator
 */
public abstract void setAuthenticator(HttpAuthenticator authenticator);
 

import org.apache.jena.atlas.web.auth.HttpAuthenticator; //导入依赖的package包/类
/**
 * Creates a new authenticator
 * 
 * @param authenticators
 *            Pool of authenticators where each represents a possible
 *            authentication method and/or set of credentials
 */
public RandomAuthenticatorPool(Collection<HttpAuthenticator> authenticators) {
    this.authenticators.addAll(authenticators);
}