Java RDFXMLWriter类代码示例

import org.openrdf.rio.rdfxml.RDFXMLWriter; //导入依赖的package包/类
@Override
public void parse(InputStream stream, ContentHandler handler,
		Metadata metadata, ParseContext context) throws IOException,
		SAXException, TikaException {

	ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
	turtleParser.setRDFHandler(new RDFXMLWriter(outputStream));
	
	try {
		turtleParser.parse(stream, metadata.get(Metadata.RESOURCE_NAME_KEY));
	} catch (Exception e) {
		throw new SAXException(e.getMessage());
	}

	ByteArrayInputStream os = new ByteArrayInputStream(outputStream.toByteArray());
	try {
		context.getSAXParser().parse(
               new CloseShieldInputStream(os),
               new OfflineContentHandler(handler));
	} finally {
		os.close();
	}
}
 

import org.openrdf.rio.rdfxml.RDFXMLWriter; //导入依赖的package包/类
public void dump(Writer writer) {
    try {
        if (contextResource.length == 0) {
            RepositoryResult<org.openrdf.model.Resource> results = conn.getContextIDs();
            while (results.hasNext()) {
                org.openrdf.model.Resource context = results.next();
                writer.append("Dumping context:" + context + "\n");
                conn.export(new RDFXMLWriter(writer), context);
            }
            dumpTriplesNotInContext(writer);
        } else {
            for (int i = 0; i < contextResource.length; i++) {
                writer.append("Dumping context:" + contextResource[i].stringValue() + "\n");
                conn.export(new RDFXMLWriter(writer), contextResource);
            }
        }
    } catch (Exception e) {
        throw new ShineRuntimeException(e);
    }
}
 

import org.openrdf.rio.rdfxml.RDFXMLWriter; //导入依赖的package包/类
public static Set<String> getAvaiableWriters(){
    N3Writer n = null;
    NTriplesWriter nt = null;
    RDFXMLPrettyWriter x2 = null;
    RDFXMLWriter x = null;
    TriGWriter tr = null;
    TriXWriter tw = null;
    TurtleWriter t = null;
    HashSet<String> results = new HashSet<String>();
    StringWriter writer = new StringWriter();
    for (RDFFormat rdfFormat:RDFFormat.values()){
        RDFWriter rdfWriter = getWriterIfPossible(rdfFormat, writer); 
        if (rdfWriter != null){
            results.add(rdfFormat.getName());
        }
    }
    return results;
}
 

import org.openrdf.rio.rdfxml.RDFXMLWriter; //导入依赖的package包/类
@Test
public void testExporter() throws IOException {
	Map<String, Class<?>> handlers = new HashMap<>();
	handlers.put( "filename.ttl", TurtleWriter.class );
	handlers.put( "filename.rdf", RDFXMLWriter.class );
	handlers.put( "filename.x", NTriplesWriter.class );

	for ( Map.Entry<String, Class<?>> en : handlers.entrySet() ) {
		RDFHandler handler;
		try ( StringWriter sw = new StringWriter() ) {
			handler = Utility.getExporterFor( en.getKey(), sw );
		}
		assertEquals( en.getValue(), handler.getClass() );
	}
}
 

import org.openrdf.rio.rdfxml.RDFXMLWriter; //导入依赖的package包/类
@Test
public void testExportStatements()
        throws Exception {
    Resource context1 = conn.getValueFactory().createURI("http://marklogic.com/test/context1");
    ValueFactory f= conn.getValueFactory();
    final URI alice = f.createURI("http://example.org/people/alice");
    URI name = f.createURI("http://example.org/ontology/name");
    Literal alicesName = f.createLiteral("Alice");

    Statement st1 = f.createStatement(alice, name, alicesName);
    conn.add(st1, context1);

    ByteArrayOutputStream out = new ByteArrayOutputStream();

    RDFXMLWriter rdfWriter = new RDFXMLWriter(out);

    String expected = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<rdf:RDF\n" +
            "\txmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n" +
            "\n" +
            "<rdf:Description rdf:about=\"http://example.org/people/alice\">\n" +
            "\t<name xmlns=\"http://example.org/ontology/\" rdf:datatype=\"http://www.w3.org/2001/XMLSchema#string\">Alice</name>\n" +
            "</rdf:Description>\n" +
            "\n" +
            "</rdf:RDF>";

    conn.exportStatements(alice, null, alicesName, true, rdfWriter, context1);
    Assert.assertEquals(expected, out.toString());
    conn.clear(context1);
}
 

import org.openrdf.rio.rdfxml.RDFXMLWriter; //导入依赖的package包/类
@Test
public void testExportStatementsAllNull()
        throws Exception {
    Resource context1 = conn.getValueFactory().createURI("http://marklogic.com/test/context1");
    ValueFactory f= conn.getValueFactory();
    final URI alice = f.createURI("http://example.org/people/alice");
    URI name = f.createURI("http://example.org/ontology/name");
    Literal alicesName = f.createLiteral("Alice");

    Statement st1 = f.createStatement(alice, name, alicesName);
    conn.add(st1, context1);

    ByteArrayOutputStream out = new ByteArrayOutputStream();

    RDFXMLWriter rdfWriter = new RDFXMLWriter(out);

    String expected = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
            "<rdf:RDF\n" +
            "\txmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n" +
            "\n" +
            "<rdf:Description rdf:about=\"http://example.org/people/alice\">\n" +
            "\t<name xmlns=\"http://example.org/ontology/\" rdf:datatype=\"http://www.w3.org/2001/XMLSchema#string\">Alice</name>\n" +
            "</rdf:Description>\n" +
            "\n" +
            "</rdf:RDF>";

    conn.exportStatements(null, null, null, false, rdfWriter, context1);
    Assert.assertEquals(expected, out.toString());
    conn.clear(context1);
}
 

import org.openrdf.rio.rdfxml.RDFXMLWriter; //导入依赖的package包/类
public void toOutputStream(OutputStream output)
		throws OpenRDFException, TransformerException, IOException {
	if (query.isGraphQuery()) {
		QueryResultUtil.report(asGraphQueryResult(), new RDFXMLWriter(
				output));
	} else if (query.isTupleQuery()) {
		QueryResultUtil.report(asTupleQueryResult(),
				new SPARQLResultsXMLWriter(output));
	} else if (query.isBooleanQuery()) {
		new SPARQLBooleanXMLWriter(output).write(asBoolean());
	} else {
		throw new AssertionError("Unknown query type");
	}
}
 

import org.openrdf.rio.rdfxml.RDFXMLWriter; //导入依赖的package包/类
public void toWriter(Writer writer) throws OpenRDFException,
		TransformerException, IOException {
	if (query.isGraphQuery()) {
		QueryResultUtil.report(asGraphQueryResult(), new RDFXMLWriter(
				writer));
	} else if (query.isTupleQuery()) {
		QueryResultUtil.report(asTupleQueryResult(),
				new SPARQLResultsXMLWriter(new XMLWriter(writer)));
	} else if (query.isBooleanQuery()) {
		new SPARQLBooleanXMLWriter(new XMLWriter(writer))
				.write(asBoolean());
	} else {
		throw new AssertionError("Unknown query type");
	}
}
 

import org.openrdf.rio.rdfxml.RDFXMLWriter; //导入依赖的package包/类
private void executeConstructQuery(GraphQuery prepareQuery, String format,
		OutputStream output) throws LodeException {
	try {
		if (GraphQueryFormats.RDFXML.toString().equals(format)) {
			prepareQuery.evaluate(new RDFXMLWriter(output));
		} else if (GraphQueryFormats.TURTLE.toString().equals(format)) {
			prepareQuery.evaluate(new TurtleWriter(output));
		}
	} catch (QueryEvaluationException | RDFHandlerException e) {
		// TODO Auto-generated catch block
		throw new LodeException(e);

	}

}
 

import org.openrdf.rio.rdfxml.RDFXMLWriter; //导入依赖的package包/类
/**
 * Gets the appropriate exporter for the given filename. "Appropriate" means
 * the file's suffix determines exporter. If no appropriate handler can be
 * found, an NTriples one is returned. Handled suffixes (case insensitive):
 * <ul>
 * <li>nt
 * <li>rdf
 * <li>ttl
 * </ul>
 *
 * @param filename the filename to determine the handler to use
 * @param out the output writer to use to create the handler
 * @return a handler (always)
 */
public static RDFHandler getExporterFor( String filename, Writer out ) {
	String suffix = FilenameUtils.getExtension( filename ).toLowerCase();
	switch ( suffix ) {
		case "rdf":
			return new RDFXMLWriter( out );
		case "ttl":
			return new TurtleWriter( out );
		default:
			return new NTriplesWriter( out );
	}
}