Java OntModelSpec类代码示例

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
/**
 * Create a model with a reasoner set based on the chosen reasoning level.
 * 
 * @param reasoningLevel
 *          The reasoning level for this model
 * 
 * @return The created ontology model
 */
private OntModel createModel(String reasoningLevel) {
  OntModel model;
  int reasoningLevelIndex;

  model = null;

  reasoningLevelIndex = getReasoningLevelIndex(reasoningLevel);

  if (reasoningLevelIndex == 0) { // None
    model = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM);
  } else if (reasoningLevelIndex == 1) { // RDFS
    model = ModelFactory
        .createOntologyModel(OntModelSpec.OWL_DL_MEM_RDFS_INF);
  } else if (reasoningLevelIndex == 2) { // OWL
    final Reasoner reasoner = PelletReasonerFactory.theInstance().create();
    final Model infModel = ModelFactory.createInfModel(reasoner,
        ModelFactory.createDefaultModel());
    model = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM,
        infModel);
  }

  return model;
}
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
static void readOwlFile (String pathToOwlFile) {
        OntModel ontologyModel =
                ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, null);
        ontologyModel.read(pathToOwlFile, "RDF/XML-ABBREV");
       // OntClass myClass = ontologyModel.getOntClass("namespace+className");

        OntClass myClass = ontologyModel.getOntClass(ResourcesUri.nwr+"domain-ontology#Motion");
        System.out.println("myClass.toString() = " + myClass.toString());
        System.out.println("myClass.getSuperClass().toString() = " + myClass.getSuperClass().toString());

        //List list =
              //  namedHierarchyRoots(ontologyModel);


       Iterator i = ontologyModel.listHierarchyRootClasses()
                .filterDrop( new Filter() {
                    public boolean accept( Object o ) {
                        return ((Resource) o).isAnon();
                    }} ); ///get all top nodes and excludes anonymous classes

       // Iterator i = ontologyModel.listHierarchyRootClasses();
        while (i.hasNext()) {
            System.out.println(i.next().toString());
/*            OntClass ontClass = ontologyModel.getOntClass(i.next().toString());
            if (ontClass.hasSubClass()) {

            }*/
        }

        String q = createSparql("event", "<http://www.newsreader-project.eu/domain-ontology#Motion>");
        System.out.println("q = " + q);
        QueryExecution qe = QueryExecutionFactory.create(q,
                ontologyModel);
        for (ResultSet rs = qe.execSelect() ; rs.hasNext() ; ) {
            QuerySolution binding = rs.nextSolution();
            System.out.println("binding = " + binding.toString());
            System.out.println("Event: " + binding.get("event"));
        }

        ontologyModel.close();
    }
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
@Test
public void testSomeMethod2() throws Exception {
  Dataset ds = TDBFactory.createDataset("/scratch/WORK2/jena/dataset2/");
  
  OntModel model1 = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, ds.getNamedModel("vijaym1"));
  OntModel model2 = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, ds.getNamedModel("vijaym2"));
  OntClass thing = model1.createClass("http://www.w3.org/2002/07/owl#Thing");
  model1.createIndividual("http://example.com/onto1#VijayRaj", thing);
  model2.createIndividual("http://example.;cegilovcom/onto2#VijayRaj", thing);
  Model m = model1.union(model2);
  
  FileWriter fw = new FileWriter("/scratch/WORK2/jena/testModels/mergetestds.xml");
  RDFDataMgr.write(fw, ds, RDFFormat.NQUADS_UTF8);
  

}
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
public CSVSToRDFConverter(String sourceFilesDir, String className, String baseNameSpace, String separator,
		String textFieldSeparator, int keyColIndex) {

	nsTBox = baseNameSpace + "model#";
	nsABox = baseNameSpace + "data#";

	this.sourceFilesDir = sourceFilesDir;
	this.className = className;
	this.separator = separator;
	this.textFieldSeparator = textFieldSeparator;

	tboxModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, null);
	aboxModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, null);

	pathSeparator = System.getProperty("file.separator");
	this.keyColIndex = keyColIndex;
}
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
/**
 * Writes the user entities to rdf
 */
private static OntModel writeUserEntries() {
	OntModel model = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
	try {
		thewebsemantic.Bean2RDF writer = new Bean2RDF(model);
		InitialContext ic = new InitialContext();
		UserService userService = (UserService) ic.lookup("java:module/UserService");
		List<User> users = userService.getAll();
		for (User u : users) {
			writer.save(u);
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
	return model;
}
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
/**
 * Writes the project entities to rdf
 */
private static OntModel writeProjectEntries() {
	OntModel model = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
	try {
		thewebsemantic.Bean2RDF writer = new Bean2RDF(model);
		InitialContext ic = new InitialContext();
		TreeNodeService treeNodeService = (TreeNodeService) ic.lookup("java:module/TreeNodeService");
		List<Project> projects = treeNodeService.getAllProjects();
		for (Project proj : projects) {
			writer.save(proj);
		}

	} catch (Exception e) {
		e.printStackTrace();
	}
	return model;
}
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
/**
	 * Read the RDF model from files.
	 */
	public static void readSemanticModelFiles() {
		logger.debug("Reading the model from a file");
		// Read the model to an existing model
		String dataDir = UQasarUtil.getDataDirPath();
		String modelPath = "file:///" + dataDir + ONTOLOGYFILE;
//		String modelPath = "file:///C:/nyrhinen/Programme/jboss-as-7.1.1.Final/standalone/data/uq-ontology-model.rdf";

		OntModel model = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
		RDFDataMgr.read(model, modelPath);
		// Test output to standard output
		//		RDFDataMgr.write(System.out, uqModel, RDFFormat.RDFXML_PRETTY);
		logger.debug("Model read from file " +modelPath);
		UQasarUtil.setUqModel(model);
		System.out.println("Reading done.");
	}
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
/**
 * This constructor should be called when the repository format is not known
 * @param _tdbFolder
 */
public SadlJenaModelGetter(IConfigurationManager configMgr, String _tdbFolder) {
	configurationManager = configMgr;
	File tdbFile = new File(_tdbFolder);
	if (tdbFile.exists()) {
		setFormat(IConfigurationManager.JENA_TDB);	// if the caller doesn't tell us the format
													// and the TDB folder exists, use it
	}
	else {
		setFormat(IConfigurationManager.RDF_XML_ABBREV_FORMAT);
	}
	setTdbFolder(_tdbFolder);
 	if (originalModelGetter == null) {
		// save original (file-based) importModelGetter
		originalModelGetter = OntModelSpec.getDefaultSpec(OWL.getURI()).getImportModelGetter();
	}
}
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
@Override
public OntModel loadOntModel(String owlFilename) {
	try {
		FileInputStream is = new FileInputStream(new File(owlFilename));
		return initOntModel(is, getOwlFormatFromFile(owlFilename));
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	OntModel ontModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
	boolean savePI = ontModel.getDocumentManager().getProcessImports();
	ontModel.getDocumentManager().setProcessImports(false);
	try {
		ontModel.read(owlFilename, getOwlFormatFromFile(owlFilename));
	}
	finally {
		ontModel.getDocumentManager().setProcessImports(savePI);
	}
	return ontModel;
}
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
/**
 * This constructor should be called when the repository format is not known
 * @param _tdbFolder
 * @throws ConfigurationException 
 */
public SadlJenaModelGetter(OntModelSpec spec, String modelFolder) throws ConfigurationException {
	this.modelFolder = modelFolder;
	File modelFolderFile = new File(modelFolder);
	if (!modelFolderFile.exists()) {
		throw new ConfigurationException("Invalid model folder (" + modelFolder + ")passed to SadlJenaModelGetter");
	}
	modelSpec = spec;
	File tdbFile = new File(getTdbFolder());
	if (tdbFile.exists()) {
		setFormat(JENA_TDB);	// if the caller doesn't tell us the format
													// and the TDB folder exists, use it
	}
	else {
		setFormat(RDF_XML_ABBREV_FORMAT);
	}
 	if (originalModelGetter == null) {
		// save original (file-based) importModelGetter
		originalModelGetter = spec.getImportModelGetter();
	}
}
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
public MetricsProcessor(String uri, org.eclipse.emf.ecore.resource.Resource resource, IConfigurationManagerForIDE configMgr, SadlModelProcessor modelProcessor) throws JenaProcessorException, ConfigurationException {
	if (resource == null) {
		throw new JenaProcessorException("MetricsProcessor constructor called with null resource");
	}
	this.modelProcessor = modelProcessor;
	String modelFolder = getModelFolderPath(resource);
	if (modelFolder != null) {
		// for JUnit tests, this will be null
		String fn = modelFolder + "/" + resource.getURI().segment(resource.getURI().segmentCount() - 1);
		baseUri = uri + ".metrics";
		filename = fn + ".metrics.owl";
		setTheJenaModel(ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM));
		this.configMgr = configMgr;
		modelOntology = getTheJenaModel().createOntology(baseUri);
		modelOntology.addComment("SADL model metrics", "en");
	}
	else {
		throw new ConfigurationException("Model folder not found");
	}
}
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
public OutputStream buscarUsuarioRdf(Long id, String urlBase){
	OutputStream ret = new ByteArrayOutputStream();
	OntModel model = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
	model.setNsPrefix( "trires", Constantes.ONTO_URI );
	
	Usuario usuario = entityManager.find(Usuario.class, id);
	if (usuario != null){
		Resource recurso = model.createResource(Constantes.USUARIO_URI + usuario.getId().toString());
		recurso.addProperty(RDF.type, VocabularioMembro.RDF_TYPE_CLASS);
		recurso.addProperty(VocabularioMembro.ID, usuario.getId().toString());
		recurso.addProperty(VocabularioMembro.DESCRICAO, usuario.getDescricao());
		recurso.addProperty(VocabularioMembro.EMAIL, usuario.getEmail());
		recurso.addProperty(VocabularioMembro.INSTITUICAO, usuario.getInstituicao());
		recurso.addProperty(VocabularioMembro.LINK_LATTES, usuario.getLinkLattes());
		recurso.addProperty(VocabularioMembro.NOME, usuario.getNome());
	}
	
	model.write(ret, "RDF/XML");
	model.close();
	return ret;
}
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
public OutputStream listarTodosRdf(String urlBase){
	OutputStream ret = new ByteArrayOutputStream();
	OntModel model = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
	model.setNsPrefix( "trires", Constantes.ONTO_URI );
	
	CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
	CriteriaQuery<Usuario> criteriaQuery = criteriaBuilder.createQuery(Usuario.class);
	Root<Usuario> from = criteriaQuery.from(Usuario.class);
	criteriaQuery.select(from);
	List<Usuario> gruposTrabalho = entityManager.createQuery(criteriaQuery).getResultList();
	for (Usuario usuario : gruposTrabalho) {
		Resource recurso = model.createResource(Constantes.USUARIO_URI + usuario.getId().toString());
		recurso.addProperty(RDF.type, VocabularioMembro.RDF_TYPE_CLASS);
		recurso.addProperty(VocabularioMembro.ID, usuario.getId().toString());
		recurso.addProperty(VocabularioMembro.DESCRICAO, usuario.getDescricao());
		recurso.addProperty(VocabularioMembro.EMAIL, usuario.getEmail());
		recurso.addProperty(VocabularioMembro.INSTITUICAO, usuario.getInstituicao());
		recurso.addProperty(VocabularioMembro.LINK_LATTES, usuario.getLinkLattes());
		recurso.addProperty(VocabularioMembro.NOME, usuario.getNome());
	}
	model.write(ret, "RDF/XML");
	model.close();
	return ret;
}
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
public ConcreteOntology(InputStream is) {
  this.model = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM_RULE_INF);
  model.read(is, null);

  this.defaultNamespace = this.model.getNsPrefixURI("");
  this.commTypes = new HashSet<String>();
  this.commTypes.addAll(this.loadViaOntology("Communication"));

  this.sectionTypes = new HashSet<>();
  this.sectionTypes.addAll(this.loadViaOntology("Section"));

  this.nerTags = new HashSet<>();
  this.nerTags.addAll(this.loadViaOntology("NamedEntityRecognitionTag"));

  this.posTags = new HashSet<>();
  this.posTags.addAll(this.loadViaOntology("PartOfSpeechTag"));
}
 

import com.hp.hpl.jena.ontology.OntModelSpec; //导入依赖的package包/类
public OntModel readIFC(String filename,String path) throws IOException {
	File file = new File("C:\\M\\xlokia.txt");
	if (!file.exists()) {
		file.createNewFile();
	}

	FileWriter fw = new FileWriter(file.getAbsoluteFile());
	BufferedWriter logfile = new BufferedWriter(fw);

	ByteArrayOutputStream strout = new ByteArrayOutputStream();
	BufferedWriter log = new BufferedWriter(new OutputStreamWriter(strout));
	ExpressReader er = new ExpressReader("c:\\jo\\IFC2X3_Final.exp");
	er.outputRDFS(log);
	IFC_ClassModel m1 = new IFC_ClassModel(filename,
			er.getEntities(), er.getTypes(), "r1");
	m1.listRDF(log, path);

	InputStream is = new ByteArrayInputStream(strout.toString().getBytes());

	OntModel model = ModelFactory
			.createOntologyModel(OntModelSpec.RDFS_MEM_TRANS_INF);
	model.read(is, null, "N3");
	return model;

}