import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
private void addFile(final InputStream in,
                     final RDFFormat format) throws Exception {
    Preconditions.checkNotNull(in);

    try {
        try (SailConnection sc = getConnection()) {
            RDFHandler h = new SailAdder(sc);
            RDFParser p = Rio.createParser(format);
            p.setRDFHandler(h);
            p.parse(in, "http://example.org/bogusBaseIRI/");
            commit(sc);
        }
    } finally {
        in.close();
    }
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
private static void propagateToHandler(List<Statement> statements,
        RDFHandler handler)
        throws RDFHandlerException, RepositoryException {
    handler.startRDF();
    handler.handleNamespace(RDF.PREFIX, RDF.NAMESPACE);
    handler.handleNamespace(RDFS.PREFIX, RDFS.NAMESPACE);
    handler.handleNamespace(DCAT.PREFIX, DCAT.NAMESPACE);
    handler.handleNamespace(XMLSchema.PREFIX, XMLSchema.NAMESPACE);
    handler.handleNamespace(OWL.PREFIX, OWL.NAMESPACE);
    handler.handleNamespace(DCTERMS.PREFIX, DCTERMS.NAMESPACE);
    handler.handleNamespace(FDP.PREFIX, FDP.NAMESPACE);
    handler.handleNamespace(R3D.PREFIX, R3D.NAMESPACE);
    handler.handleNamespace("lang",
            "http://id.loc.gov/vocabulary/iso639-1/");
    for (Statement st : statements) {
        handler.handleStatement(st);
    }
    handler.endRDF();
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
@Test
public void callsStartRDFAndEndRDFOnGivenHandler() throws Exception {
    // Arrange
    RDFHandler rdfHandler = mock(RDFHandler.class);
    Collection<Statement> statements = ImmutableList.of(
            createHttpStatement("s1", "p", "o", "g1")
    );
    Repository repository = FTDPUTestUtils.createRepository(statements);

    // Act
    try (MockRDFDataUnit rdfDataUnit = getDataUnit(statements);
         AllTriplesDataUnitLoader loader = getLoader(rdfDataUnit, 2)
    ) {
        loader.loadAllTriples(rdfHandler);
    }

    // Assert
    Mockito.verify(rdfHandler).startRDF();
    Mockito.verify(rdfHandler).endRDF();
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
/**
 * evaluate graph query with RDFHandler
 *
 * @param resultHandler
 * @throws QueryEvaluationException
 * @throws RDFHandlerException
 */
@Override
public void evaluate(RDFHandler resultHandler) throws QueryEvaluationException, RDFHandlerException {
    GraphQueryResult queryResult = evaluate();
    if(queryResult.hasNext())
    {
        QueryResults.report(queryResult, resultHandler);
    }
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
/**
 * Exports repository data from the specified context and passes it to the handler.
 *
 * @param contextUri Context from which the data should be exported. Optional
 * @param handler    Handler for the exported data
 */
public void getRepositoryData(URI contextUri, RDFHandler handler) {
    try {
        try (final RepositoryConnection connection = sesameRepository.getRepository().getConnection()) {
            final ValueFactory valueFactory = connection.getValueFactory();
            if (contextUri != null) {
                connection.export(handler, valueFactory.createIRI(contextUri.toString()));
            } else {
                connection.export(handler);
            }
        }
    } catch (RepositoryException | RDFHandlerException e) {
        LOG.error("Unable to read data from repository.", e);
    }
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
public RDF4JJSONLDTripleCallback(RDFHandler nextHandler, ValueFactory vf,
        ParserConfig parserConfig, ParseErrorListener parseErrorListener) {
    this.handler = nextHandler;
    this.vf = vf;
    this.parserConfig = parserConfig;
    this.parseErrorListener = parseErrorListener;
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
private int loadAllTriplesForGraph(IRI dataGraphURI, RDFHandler rdfHandler) throws OpenRDFException, DataUnitException {
    LOG.debug("Loading input quads from data unit for graph {}", dataGraphURI);
    int totalLoadedQuads = 0;
    int lastLoadedQuads = Integer.MAX_VALUE;
    for (int offset = 0; lastLoadedQuads >= maxSparqlResultsSize; offset += lastLoadedQuads) {
        String query = formatQuery(dataGraphURI, maxSparqlResultsSize, offset);
        lastLoadedQuads = addQuadsFromQuery(dataGraphURI, query, rdfHandler);
        totalLoadedQuads += lastLoadedQuads;

        if ((totalLoadedQuads - lastLoadedQuads) / LOG_LOOP_SIZE != totalLoadedQuads / LOG_LOOP_SIZE) {
            LOG.info("ODCS-FusionTool: Loaded {} quads from graph {} so far", totalLoadedQuads, dataGraphURI);
        }
    }
    return totalLoadedQuads;
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
private int addQuadsFromQuery(IRI dataGraphURI, String sparqlQuery, RDFHandler rdfHandler) throws OpenRDFException, DataUnitException {
    int quadCount = 0;
    RepositoryConnection connection = getConnection();
    TupleQueryResult resultSet = connection.prepareTupleQuery(QueryLanguage.SPARQL, sparqlQuery).evaluate();
    try {
        ValueFactory valueFactory = connection.getRepository().getValueFactory();
        while (resultSet.hasNext()) {
            BindingSet bindings = resultSet.next();
            Statement quad = valueFactory.createStatement(
                    (Resource) bindings.getValue("s"),
                    (IRI) bindings.getValue("p"),
                    bindings.getValue("o"),
                    dataGraphURI);
            rdfHandler.handleStatement(quad);
            quadCount++;
        }
    } finally {
        resultSet.close();
        //if (connection instanceof VirtuosoRepositoryConnection)
        //    // fix potential error "Too many open statements" - Virtuoso doesn't release resources properly
        //    try {
        //        closeConnection();
        //    } catch (RepositoryException e) {
        //        // ignore
        //    }
        //}
    }
    return quadCount;
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
@Override
public RDFParser setRDFHandler(RDFHandler handler) {
  if (handler instanceof TimRdfHandler) {
    // It might be nicer to override statement, to make it contain the action, but it takes to much effort for now.
    ((TimRdfHandler) handler).registerActionSupplier(() -> actions.pop());
  }
  return super.setRDFHandler(handler);
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
private static void emit(final RDFHandler out, final Resource s, final IRI p, final Value o)
        throws RDFHandlerException {
    final ValueFactory vf = SimpleValueFactory.getInstance();
    out.handleStatement(vf.createStatement(s, p, o));
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
/**
 * @return the handler
 */
public RDFHandler getHandler() {
    return handler;
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
@Override
protected void parseSynchronusly() throws IOException {
    final Optional<RDFFormat> formatByMimeType = getContentType().flatMap(Rio::getParserFormatForMIMEType);
    final String base = getBase().map(IRI::getIRIString).orElse(null);

    final ParserConfig parserConfig = getParserConfig();
    // TODO: Should we need to set anything?
    final RDFLoader loader = new RDFLoader(parserConfig, rdf4jTermFactory.getValueFactory());
    final RDFHandler rdfHandler = makeRDFHandler();
    if (getSourceFile().isPresent()) {
        // NOTE: While we could have used
        // loader.load(sourcePath.toFile()
        // if the path fs provider == FileSystems.getDefault(),
        // that RDFLoader method does not use absolute path
        // as the base URI, so to be consistent
        // we'll always do it with our own input stream
        //
        // That means we may have to guess format by extensions:
        final Optional<RDFFormat> formatByFilename = getSourceFile().map(Path::getFileName).map(Path::toString)
                .flatMap(Rio::getParserFormatForFileName);
        // TODO: for the excited.. what about the extension after following
        // symlinks?

        final RDFFormat format = formatByMimeType.orElse(formatByFilename.orElse(null));
        try (InputStream in = Files.newInputStream(getSourceFile().get())) {
            loader.load(in, base, format, rdfHandler);
        }
    } else if (getSourceIri().isPresent()) {
        try {
            // TODO: Handle international IRIs properly
            // (Unicode support for for hostname, path and query)
            final URL url = new URL(getSourceIri().get().getIRIString());
            // TODO: This probably does not support https:// -> http://
            // redirections
            loader.load(url, base, formatByMimeType.orElse(null), makeRDFHandler());
        } catch (final MalformedURLException ex) {
            throw new IOException("Can't handle source URL: " + getSourceIri().get(), ex);
        }
    }
    // must be getSourceInputStream then, this is guaranteed by
    // super.checkSource();
    loader.load(getSourceInputStream().get(), base, formatByMimeType.orElse(null), rdfHandler);
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
/**
 * Exports statements via RDFHandler.
 *
 *
 *
 * @param subject Subject of the statement.
 * @param predicate Predicate of the statement.
 * @param object Object of the statement.
 * @param includeInferred if false returns only explicit statements. If true returns both explicit and implicit statements.
 * @param handler RDFHandler
 * @param contexts Var-arg for specified contexts.
 * @throws RepositoryException
 * @throws RDFHandlerException
 */
// TBD- should refactor
@Override
public void exportStatements(Resource subject, IRI predicate, Value object, boolean includeInferred, RDFHandler handler, Resource... contexts) throws RepositoryException, RDFHandlerException {
    try {
        RepositoryResult<Statement> st = this.getStatements(subject, predicate, object, includeInferred, contexts);
        handler.startRDF();
        QueryResults.stream(st).forEach(handler::handleStatement);
        handler.endRDF();
    }
    catch (MalformedQueryException | QueryEvaluationException e) {
        throw new RepositoryException(e);
    }
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
/**
 * Exports statements via RDFHandler.
 *
 *
 *
 * @param handler RDFHandler
 * @param contexts Var-arg for specified contexts.
 * @throws RepositoryException
 * @throws RDFHandlerException
 */
// TBD- should refactor
@Override
public void export(RDFHandler handler, Resource... contexts) throws RepositoryException, RDFHandlerException {
    exportStatements(null, null, null, false, handler, contexts);
}
 

import org.eclipse.rdf4j.rio.RDFHandler; //导入依赖的package包/类
/**
 * @param handler
 *            the handler to set
 */
public void setHandler(RDFHandler handler) {
    this.handler = handler;
}