import org.eclipse.rdf4j.model.vocabulary.OWL; //导入依赖的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.model.vocabulary.OWL; //导入依赖的package包/类
@Test
public void getsUriMapping() throws Exception {
    // Arrange
    sameAsDataUnit = new MockRDFDataUnit(ImmutableList.of(
            VF.createStatement(createHttpUri("a1"), OWL.SAMEAS, createHttpUri("a2")),
            VF.createStatement(createHttpUri("a2"), OWL.SAMEAS, createHttpUri("a3")),
            VF.createStatement(createHttpUri("b1"), OWL.SAMEAS, createHttpUri("b2")),
            VF.createStatement(createHttpUri("b2"), OWL.SAMEAS, createHttpUri("b3")),
            VF.createStatement(createHttpUri("p1"), OWL.SAMEAS, createHttpUri("p2")),
            VF.createStatement(createHttpUri("p2"), OWL.SAMEAS, createHttpUri("p3"))
    ));

    File resultDir = testDir.newFolder("dpuInstanceDir");
    when(dpuContext.getDpuInstanceDirectory()).thenReturn(resultDir.toURI().toString());

    ConfigContainer config = mock(ConfigContainer.class);
    when(config.getSameAsLinkTypes()).thenReturn(ImmutableSet.of(OWL.SAMEAS));
    when(config.getPropertyResolutionStrategies()).thenReturn(ImmutableMap.<IRI, ResolutionStrategy>of(createHttpUri("p2"), new ResolutionStrategyImpl()));
    when(config.getPreferredCanonicalURIs()).thenReturn(ImmutableSet.of(createHttpUri("a2").stringValue()));
    Files.write(new File(resultDir, "canonicalUris.txt").toPath(), ImmutableList.of(createHttpUri("b2").stringValue()), Charset.defaultCharset());
    when(config.getCanonicalURIsFileName()).thenReturn("canonicalUris.txt");

    // Act
    FusionToolDpuComponentFactory componentFactory = getComponentFactory(config);
    UriMappingIterable uriMappingIterable = componentFactory.getUriMapping();

    // Assert
    assertThat(uriMappingIterable.mapResource(createHttpUri("a1")), is((Resource) createHttpUri("a2")));
    assertThat(uriMappingIterable.mapResource(createHttpUri("a2")), is((Resource) createHttpUri("a2")));
    assertThat(uriMappingIterable.mapResource(createHttpUri("a3")), is((Resource) createHttpUri("a2")));
    assertThat(uriMappingIterable.mapResource(createHttpUri("b1")), is((Resource) createHttpUri("b2")));
    assertThat(uriMappingIterable.mapResource(createHttpUri("b2")), is((Resource) createHttpUri("b2")));
    assertThat(uriMappingIterable.mapResource(createHttpUri("b3")), is((Resource) createHttpUri("b2")));
    assertThat(uriMappingIterable.mapResource(createHttpUri("p1")), is((Resource) createHttpUri("p2")));
    assertThat(uriMappingIterable.mapResource(createHttpUri("p2")), is((Resource) createHttpUri("p2")));
    assertThat(uriMappingIterable.mapResource(createHttpUri("p3")), is((Resource) createHttpUri("p2")));
    assertThat(Iterables.size(uriMappingIterable), is(6));
}
 

import org.eclipse.rdf4j.model.vocabulary.OWL; //导入依赖的package包/类
public static void export(final Connection connection, final Path path)
        throws SQLException, IOException, RDFHandlerException {

    final Map<Long, String> screenNames = loadScreenNames(connection, path);

    connection.setAutoCommit(false);

    final ValueFactory vf = SimpleValueFactory.getInstance();

    try (Writer writer = new OutputStreamWriter(
            new GZIPOutputStream(new FileOutputStream(path.toFile())), Charsets.UTF_8)) {

        final RDFWriter out = Rio.createWriter(RDFFormat.NTRIPLES, writer);
        out.startRDF();

        int counter = 0;
        try (PreparedStatement stmt = connection.prepareStatement("" //
                + "SELECT resource_id, uid, score, is_alignment\n" //
                + "FROM alignments\n" //
                + "WHERE version=2\n" //
                + "ORDER BY resource_id ASC, score DESC")) {
            stmt.setFetchSize(1000);
            try (ResultSet rs = stmt.executeQuery()) {
                IRI lastEntity = null;
                int rank = 1;
                while (rs.next()) {
                    final long uid = rs.getLong("uid");
                    final String screenName = screenNames.get(uid);
                    Preconditions.checkState(screenName != null);
                    final IRI entity = vf.createIRI(rs.getString("resource_id"));
                    final IRI account = vf.createIRI(
                            "http://twitter.com/" + screenName.replaceAll("\\s", "+"));
                    final BNode candidate = vf.createBNode();
                    final float score = rs.getFloat("score");
                    final boolean align = rs.getBoolean("is_alignment");
                    rank = entity.equals(lastEntity) ? rank + 1 : 1;
                    lastEntity = entity;
                    LOGGER.debug("Processing candidate {} {} {} {}", entity, candidate, score,
                            align);
                    if (align) {
                        emit(out, entity, FOAF.ACCOUNT, account);
                    }
                    emit(out, entity, OWL.SAMEAS, entity);
                    emit(out, entity, SL.CANDIDATE_PROPERTY, candidate);
                    emit(out, candidate, SL.RANK, vf.createLiteral(rank));
                    emit(out, candidate, SL.CONFIDENCE, vf.createLiteral(score));
                    emit(out, candidate, SL.ACCOUNT, account);
                    emit(out, account, DCTERMS.IDENTIFIER, vf.createLiteral(uid));
                    emit(out, account, FOAF.ACCOUNT_NAME, vf.createLiteral(screenName));
                    if (++counter % 10000 == 0) {
                        LOGGER.info("{} candidates processed", counter);
                    }
                }
            }
        }

        out.endRDF();
    }
}