Java FOAF类代码示例

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
/**
 * Adds a property value (a triple describing the Resource).
 *
 * @param tripleDF the triple display format
 * @throws RMapWebException the RMap web exception
 */
public void addPropertyValue(TripleDisplayFormat tripleDF) throws RMapWebException {
	if (tripleDF!=null) {
		
		//these predicates should be first in the list. Property Values list is ordered alphabetically.
		String[] bubbleToTop = {DC.TITLE.toString(),DCTERMS.TITLE.toString(),FOAF.NAME.toString(),
								RDFS.LABEL.toString(), RDFS.SEEALSO.toString(), DC.IDENTIFIER.toString(),
								DCTERMS.IDENTIFIER.toString(), SKOS.PREF_LABEL.toString()};
		
		String listKey;
		String predicate= tripleDF.getPredicate().toString();
		//if it's a title, name or label, bubble to top of list.
		if (Arrays.asList(bubbleToTop).contains(predicate)){
			listKey = tripleDF.getSubjectDisplay()+"______a" + tripleDF.getPredicateDisplay()+tripleDF.getObjectDisplay();	
		} else {
			listKey = tripleDF.getSubjectDisplay()+tripleDF.getPredicateDisplay()+tripleDF.getObjectDisplay();	
		}
		
		this.propertyValues.put(listKey, tripleDF);
	} else {
		throw new RMapWebException(ErrorCode.ER_RESOURCE_PROPERTY_VALUE_NULL);
	}
}
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
/**
 * Write DCAT catalog to XML.
 * 
 * @param w XML writer
 * @param con RDF triple store connection
 */
private static void writeCatalog(XMLStreamWriter w, RepositoryConnection con) 
		throws XMLStreamException {
	String cat = "http://data.gov.be/catalog";
	
	w.writeStartElement("rdf:RDF");
	writePrefixes(w);
	
	w.writeStartElement("dcat:Catalog");
	w.writeAttribute("dct:identifier", cat);
	w.writeAttribute("rdf:about", cat);

	IRI uri = con.getValueFactory().createIRI(cat);
	writeGeneric(w, con, uri);		
	writeReferences(w, con, uri, FOAF.HOMEPAGE, "foaf:homepage");
	writeLicenses(w, con, uri, DCTERMS.LICENSE);
	writeDatasets(w, con);
	
	w.writeEndElement();
	
	writeOrgs(w, con);
	
	w.writeEndElement();
}
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
/**
 * Parse CKAN organization
 *
 * @param store
 * @param uri
 * @param json
 * @param lang language code
 * @throws RepositoryException
 * @throws MalformedURLException
 */
protected void ckanOrganization(Storage store, IRI uri, JsonObject json, String lang)
		throws RepositoryException, MalformedURLException {
	if (!json.isNull(CkanJson.ORGANIZATION)) {
		JsonObject obj = json.getJsonObject(CkanJson.ORGANIZATION);

		if (obj.getBoolean(CkanJson.IS_ORG)) {
			String s = obj.getString(CkanJson.ID, "");
			IRI org = store.getURI(makeOrgURL(s).toString());
			store.add(uri, DCTERMS.PUBLISHER, org);
			store.add(org, RDF.TYPE, FOAF.ORGANIZATION);

			parseString(store, org, obj, CkanJson.NAME, FOAF.NAME, lang);
		}
	}
}
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
/**
 * Sets the statement containing the Agent Name.
 *
 * @param name statement containing the Agent Name
 * @throws RMapDefectiveArgumentException the RMap defective argument exception
 */
protected void setNameStmt (Value name) throws RMapDefectiveArgumentException{
	if (name == null || name.toString().length()==0)
		{throw new RMapDefectiveArgumentException("RMapAgent name is null or empty");}
	Statement stmt = ORAdapter.getValueFactory().createStatement(this.context, 
			FOAF.NAME, name, this.context);
	this.nameStmt = stmt;
}
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
/**
 *
 * Get RDF statements from catalog metadata object
 *
 * @param model RDF model with common metadata properties
 * @param metadata CatalogMetadata object
 * @return List of RDF statements
 * @throws MetadataException
 */
private static List<Statement> getStatements(Model model,
        CatalogMetadata metadata)
        throws MetadataException {
    try {
        Preconditions.checkNotNull(metadata.getPublisher(),
                "Metadata publisher must not be null.");
        Preconditions.checkNotNull(metadata.getThemeTaxonomys(),
                "Metadata dcat:themeTaxonomy must not be null.");
        Preconditions.checkArgument(!metadata.getThemeTaxonomys().isEmpty(),
                "Metadata dcat:themeTaxonomy must not be empty.");
    } catch (NullPointerException | IllegalArgumentException ex) {
        throw (new MetadataException(ex.getMessage()));
    }
    LOGGER.info("Adding catalogy metadata properties to the rdf model");
    addStatement(model, metadata.getUri(), RDF.TYPE, DCAT.TYPE_CATALOG);
    addStatement(model,metadata.getUri(), FOAF.HOMEPAGE, 
            metadata.getHomepage());
    addStatement(model,metadata.getUri(), DCTERMS.ISSUED,
                metadata.getCatalogIssued());
    addStatement(model,metadata.getUri(), DCTERMS.MODIFIED,
                metadata.getCatalogModified());
    metadata.getThemeTaxonomys().stream().forEach((themeTax) -> {
        addStatement(model, metadata.getUri(), DCAT.THEME_TAXONOMY, 
                themeTax);
    });
    metadata.getDatasets().stream().forEach((dataset) -> {
        addStatement(model, metadata.getUri(), DCAT.DATASET, dataset);
    });
    return getStatements(model);
}
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
/**
 * Add agent instance's rdf statements
 * @param model
 * @param subj
 * @param pred
 * @param objc 
 */
private static void addAgentStatements(Model model, IRI subj, IRI pred, 
        Agent objc) {
    if (objc != null) {
        addStatement(model, subj, pred, objc.getUri());
        addStatement(model, objc.getUri(), RDF.TYPE, objc.getType());
        if (objc.getName() == null) {
            String errMsg = "No publisher name provided";
            LOGGER.info(errMsg);
        } else {
            addStatement(model, objc.getUri(), FOAF.NAME, objc.getName());
        }
    }        
}
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
/**
 * Parse RDF statements to create catalog metadata object
 *
 * @param statements List of RDF statement list
 * @param catalogURI Catalog URI
 * @return CatalogMetadata object
 */
@Override
public CatalogMetadata parse(@Nonnull List<Statement> statements,
        @Nonnull IRI catalogURI) {
    Preconditions.checkNotNull(catalogURI,
            "Catalog URI must not be null.");
    Preconditions.checkNotNull(statements,
            "Catalog statements must not be null.");
    LOGGER.info("Parsing catalog metadata");

    CatalogMetadata metadata = super.parse(statements, catalogURI);
    List<IRI> datasets = new ArrayList();
    ValueFactory f = SimpleValueFactory.getInstance();
    for (Statement st : statements) {
        Resource subject = st.getSubject();
        IRI predicate = st.getPredicate();
        Value object = st.getObject();

        if (subject.equals(catalogURI)) {
            if (predicate.equals(FOAF.HOMEPAGE)) {
                metadata.setHomepage((IRI) object);
            } else if (predicate.equals(DCAT.THEME_TAXONOMY)) {
                metadata.getThemeTaxonomys().add((IRI) object);
            } else if (predicate.equals(DCAT.DATASET)) {
                datasets.add((IRI) object);
            } else if (predicate.equals(DCTERMS.ISSUED)) {
                metadata.setCatalogIssued(f.createLiteral(object.
                        stringValue(), XMLSchema.DATETIME));
            } else if (predicate.equals(DCTERMS.MODIFIED)) {
                metadata.setCatalogModified(f.createLiteral(object.
                        stringValue(), XMLSchema.DATETIME));
            }
        }
    }
    if(!datasets.isEmpty()) {
        metadata.setDatasets(datasets);
    }
    return metadata;
}
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
/**
 * Create agent object
 * 
 * @param statements    List of rdf statements
 * @param agentURI      Agent uri
 * @return 
 */
public static Agent parse(@Nonnull List<Statement> statements,
        @Nonnull IRI agentURI) {
    Preconditions.checkNotNull(agentURI,
            "Agent URI must not be null.");
    Preconditions.checkNotNull(statements,
            "Agent statements must not be null.");
    Preconditions.checkArgument(!statements.isEmpty(),
            "Agent statements must not be empty.");
    LOGGER.info("Parsing agent");
    Agent agent = new Agent();
    agent.setUri(agentURI);
    for (Statement st : statements) {
        Resource subject = st.getSubject();
        IRI predicate = st.getPredicate();
        Value object = st.getObject();

        if (subject.equals(agentURI)) {
            if (predicate.equals(RDF.TYPE)) {
                agent.setType((IRI) object);
            } else if (predicate.equals(FOAF.NAME)) {
                ValueFactory f = SimpleValueFactory.getInstance();
                agent.setName(f.createLiteral(object.stringValue(),
                        XMLSchema.STRING));
            }
        }
    }
    return agent;
}
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
/**
 * Write XML namespace prefixes
 * 
 * @param w writer
 * @throws XMLStreamException
 */			
private static void writePrefixes(XMLStreamWriter w) throws XMLStreamException {
	w.writeNamespace(DCAT.PREFIX, DCAT.NAMESPACE);
	w.writeNamespace("dct", DCTERMS.NAMESPACE);
	w.writeNamespace(FOAF.PREFIX, FOAF.NAMESPACE);
	w.writeNamespace(RDF.PREFIX, RDF.NAMESPACE);
	w.writeNamespace(RDFS.PREFIX, RDFS.NAMESPACE);
	w.writeNamespace("schema", "http://schema.org/");
	w.writeNamespace(VCARD4.PREFIX, VCARD4.NAMESPACE);
}
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
/**
 * Write FOAF organization
 * 
 * @param w XML writer
 * @param con RDF triple store connection
 * @param uri URI of the organization
 * @throws XMLStreamException 
 */
private static void writeOrg(XMLStreamWriter w, RepositoryConnection con,
		IRI uri) throws XMLStreamException {
	if (uri.stringValue().startsWith(BELGIF_PREFIX)) {
		w.writeStartElement("foaf:Organization");	
		w.writeAttribute("rdf:about", uri.stringValue());
	
		writeLiterals(w, con, uri, FOAF.NAME, "foaf:name");
		writeReferences(w, con, uri, FOAF.HOMEPAGE, "foaf:homepage");
		writeReferences(w, con, uri, FOAF.MBOX, "foaf:mbox");
	
		w.writeEndElement();
	}
}
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
/**
 * Write FOAF organizations
 * 
 * @param w XML writer
 * @param con RDF triple store connection
 * @throws XMLStreamException 
 */
private static void writeOrgs(XMLStreamWriter w, RepositoryConnection con) 
		throws XMLStreamException {
	int nr = 0;
	
	try (RepositoryResult<Statement> res = con.getStatements(null, RDF.TYPE, FOAF.ORGANIZATION)) {
		while (res.hasNext()) {
			nr++;
			writeOrg(w, con, (IRI) res.next().getSubject());
		}
	}
	logger.info("Wrote {} organizations", nr);
}
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
/**
 * Extra DCAT catalog info
 *
 * @param store RDF store
 * @param catalog catalog URI
 * @throws org.eclipse.rdf4j.repository.RepositoryException
 */
public void generateCatalogInfo(Storage store, IRI catalog)
		throws RepositoryException {
	store.add(catalog, DCTERMS.TITLE, "DCAT Catalog for " + getName(), "en");
	store.add(catalog, DCTERMS.DESCRIPTION, "Converted by Fedict's converter", "en");
	store.add(catalog, DCTERMS.MODIFIED, DATEFMT.format(new Date()));
	store.add(catalog, DCTERMS.LICENSE, DATAGOVBE.LICENSE_CC0);
	store.add(catalog, FOAF.HOMEPAGE, getBase());

	String[] langs = getAllLangs();
	for (String lang : langs) {
		store.add(catalog, DCTERMS.LANGUAGE, MDR_LANG.MAP.get(lang));
	}
}
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
public static void main(String... args) throws RepositoryException, IOException, RDFParseException, MalformedQueryException, QueryEvaluationException {

        // instantiate repository
        MarkLogicRepository repo = new MarkLogicRepository("localhost",8200, new DatabaseClientFactory.DigestAuthContext("admin", "admin"));
        repo.initialize();

        // get repository connection
        MarkLogicRepositoryConnection conn = repo.getConnection();

        // return number of triples contained in repository
        logger.info("number of triples: {}", conn.size());

        // add triples from a file
        File inputFile = new File("src/main/resources/testdata/test-small.owl");
        conn.add(inputFile, null, RDFFormat.RDFXML, (Resource) null);

        logger.info("number of triples: {}", conn.size());

        // add a few constructed triples
        Resource context1 = conn.getValueFactory().createIRI("http://marklogic.com/examples/context1");
        Resource context2 = conn.getValueFactory().createIRI("http://marklogic.com/examples/context2");
        ValueFactory f= conn.getValueFactory();
        String namespace = "http://example.org/";
        IRI john = f.createIRI(namespace, "john");
        conn.add(john, RDF.TYPE, FOAF.PERSON,context1);
        conn.add(john, RDFS.LABEL, f.createLiteral("John", XMLSchema.STRING),context2);

        // check if triples with subject john exist in repository
        String checkJohnQuery = "ASK { <http://example.org/john> ?p ?o .}";
        BooleanQuery booleanJohnQuery = conn.prepareBooleanQuery(QueryLanguage.SPARQL, checkJohnQuery);
        logger.info("result of query: {}",booleanJohnQuery.evaluate());

        // perform SPARQL query with pagination
        String queryString = "select * { ?s ?p ?o }";
        MarkLogicTupleQuery tupleQuery = conn.prepareTupleQuery(QueryLanguage.SPARQL, queryString);
        tupleQuery.setIncludeInferred(true);
        TupleQueryResult results = tupleQuery.evaluate(1,10);

        //iterate through query results
        while(results.hasNext()){
            BindingSet bindings = results.next();
            logger.info("subject:{}",bindings.getValue("s"));
            logger.info("predicate:{}", bindings.getValue("p"));
            logger.info("object:{}", bindings.getValue("o"));
        }

        // clear all triples
        conn.clear();
        logger.info("number of triples: {}", conn.size());

        // close connection and shutdown repository
        conn.close();
        repo.shutDown();

        System.exit(0);
    }
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
@Test
public void testWriteAndFind() throws Exception {
    Repository repo = new SailRepository(new MemoryStore());
    repo.initialize();

    try (RepositoryConnection connection = repo.getConnection()) {

        ValueFactory vf = SimpleValueFactory.getInstance();

        String ex = "http://example.org/";

        IRI lilie = vf.createIRI(ex, "Lilie");

        connection.add(lilie, FOAF.NAME, vf.createLiteral("Lilie"));
        connection.add(lilie, FOAF.MBOX, vf.createIRI("mailto:[email protected]"));
        connection.add(lilie, FOAF.KNOWS, vf.createIRI(ex, "Bob"));

        boolean hasStatement = connection.hasStatement(vf.createIRI(ex, "Lilie"), null, null, false);
        assertTrue(hasStatement);

        RepositoryResult<Statement> statements = connection.getStatements(vf.createIRI(ex, "Lilie"), FOAF.NAME, null);

        assertEquals("Lilie", statements.next().getObject().stringValue());
    }

}
 

import org.eclipse.rdf4j.model.vocabulary.FOAF; //导入依赖的package包/类
/**
 * Creates an RMapAgent object from a list of statements - must include statements for 1 name, 1 id provider, 1 user auth id.
 *
 * @param stmts the set of statements that describe the RMapAgent
 * @throws RMapException the RMap exception
 * @throws RMapDefectiveArgumentException the RMap defective argument exception
 */
public static ORMapAgent asAgent(Set<Statement> stmts, Supplier<URI> idSupplier) throws RMapException,
        RMapDefectiveArgumentException {

    if (stmts == null) {
        throw new RMapDefectiveArgumentException(NULL_STATEMENTS);
    }

    Identifiers identifiers = identifiers(stmts, RMAP.AGENT).orElseThrow(() ->
            new RMapDefectiveArgumentException(MISSING_RDF_TYPE));

    if (identifiers.assertedId == null || identifiers.assertedId.stringValue().trim().length() == 0) {
        throw new RMapException(MISSING_AGENT_IRI);
    }

    if (identifiers.officalId == null || identifiers.officalId.stringValue().trim().length() == 0) {
        //if disco has come in without a context, generate ID. This will happen if it's a new disco
        identifiers.officalId = ORAdapter.uri2Rdf4jIri(idSupplier.get());
    }

    ORMapAgent agent = new ORMapAgent((IRI)identifiers.officalId);

    //loop through and check we have all vital components for Agent.
    boolean typeRecorded = false;
    boolean nameRecorded = false;
    boolean idProviderRecorded = false;
    boolean authIdRecorded = false;

    for (Statement stmt : stmts) {
        Resource subject = stmt.getSubject();
        IRI predicate = stmt.getPredicate();
        Value object = stmt.getObject();

        LOG.debug("Processing Agent statement: {} - {} - {}", subject, predicate, object);
        
        boolean agentIsSubject = subject.stringValue().equals(identifiers.assertedId.stringValue());
        if (agentIsSubject && predicate.equals(RDF.TYPE) && object.equals(RMAP.AGENT) && !typeRecorded) {
            agent.setTypeStatement(RMapObjectType.AGENT);
            typeRecorded = true;
        } else if (agentIsSubject && predicate.equals(FOAF.NAME) && !nameRecorded) {
            agent.setNameStmt(object);
            nameRecorded = true;
        } else if (agentIsSubject && predicate.equals(RMAP.IDENTITYPROVIDER) && !idProviderRecorded) {
            agent.setIdProviderStmt((IRI) object);
            idProviderRecorded = true;
        } else if (agentIsSubject && predicate.equals(RMAP.USERAUTHID) && !authIdRecorded) {
            agent.setAuthIdStmt((IRI) object);
            authIdRecorded = true;
        } else { //there is an invalid statement in there
            throw new RMapException("Invalid statement found in RMap:Agent object: (" + subject + ", " + predicate + ", " + object + "). "
                    + "Agents should contain 1 rdf:type definition, 1 foaf:name, 1 rmap:idProvider, and 1 rmap:userAuthId.");
        }
    }
    if (!typeRecorded) { //should have already been caught but JIC.
        throw new RMapException("The foaf:name statement is missing from the Agent");
    }
    if (!nameRecorded) {
        throw new RMapException("The foaf:name statement is missing from the Agent");
    }
    if (!idProviderRecorded) {
        throw new RMapException("The rmap:idProvider statement is missing from the Agent");
    }
    if (!authIdRecorded) {
        throw new RMapException("The rmap:userAuthId statement is missing from the Agent");
    }

    return agent;
}