import org.apache.jena.query.text.EntityDefinition; //导入依赖的package包/类
public void init(String db, String uri, String lucene) {

    	Dataset ds = TDBFactory.createDataset(db);
        
        // Lucene configuration
        try {
            Directory luceneDir = FSDirectory.open(new File(lucene));
            EntityDefinition entDef = new EntityDefinition("comment", "text", RDFS.comment);
            // Set uid in order to remove index entries automatically
            entDef.setUidField("uid");
            StandardAnalyzer stAn = new StandardAnalyzer(Version.LUCENE_4_9);
            dataset = TextDatasetFactory.createLucene(ds, luceneDir, entDef, stAn);
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        baseURI = uri;
        servers = new ArrayList<>();
        tdQueue = new PriorityQueue<ThingDescription>();
        loadTDQueue();
    }
 

import org.apache.jena.query.text.EntityDefinition; //导入依赖的package包/类
/**
 * Creates an in-memory Jena TDB data set and Lucene index from code.
 * @return
 */
public Dataset createMemDatasetFromCode(){
    log.info("Construct an in-memory dataset with in-memory lucene index using code") ;
    TextQuery.init();
    // Build a text dataset by code.
    // Here , in-memory base data and in-memory Lucene index
    // Base data
    Dataset jenads = DatasetFactory.createMem() ;
    Property streetAddress = jenads.getDefaultModel().createProperty("http://schema.org/streetAddress");
    // Define the index mapping
    //EntityDefinition entDef = new EntityDefinition("uri", "text", RDFS.label.asNode()) ;
    EntityDefinition entDef = new EntityDefinition("uri", "text", streetAddress.asNode()) ;
    // Lucene, in memory.
    Directory dir = new RAMDirectory();
    // Join together into a dataset
    Dataset ds = TextDatasetFactory.createLucene(jenads, dir, entDef) ;
    return ds ;
}
 

import org.apache.jena.query.text.EntityDefinition; //导入依赖的package包/类
/**
 * Creates a persistent Jena TDB data set and Lucene index. 
 * @return
 * @throws IOException 
 */
public Dataset createPersistentDatasetFromCode() throws IOException{
    log.info("Construct a persistent Jena data set with lucene index using code") ;
    // Build a text dataset by code.
    TextQuery.init();
    // Remove old files and folders
    deleteFiles(JENA_TDB_TEMP_FOLDER);
    deleteFiles(LUCENE_INDEX_TEMP_FOLDER);
    // Creates new folders
    JENA_TDB_TEMP_FOLDER.mkdirs();
    LUCENE_INDEX_TEMP_FOLDER.mkdirs();
    // Creates persisted Jena data set and Lucene index
    Dataset jenaDataset = TDBFactory.createDataset(JENA_TDB_TEMP_FOLDER.getAbsolutePath()) ;
    // Lucene, persisted.
    Directory luceneIndex = FSDirectory.open(LUCENE_INDEX_TEMP_FOLDER);
    // Define the index mapping
    EntityDefinition entDef = new EntityDefinition("uri", "text", RDFS.label.asNode()) ;
    
    
    // Join together into a dataset
    return TextDatasetFactory.createLucene(jenaDataset, luceneIndex, entDef) ;
}
 

import org.apache.jena.query.text.EntityDefinition; //导入依赖的package包/类
/** Create an index using your own model saving you the time needed to import the model when using an endpoint.
 * If you only have an endpoint or want to index a subset of the triples,
 * use the static methods {@link #createIndex(String, String, List)}, {@link #createClassIndex(String, String)} or {@link #createPropertyIndex(String, String)}.
 * All triples (uri,rdfs:label,label) will be put into the index.
 * @param model the jena model containing the rdf:label statements that you want to index. Changes to the model after the construtor call are probably not indexed.
 * @param minSimilarity Between 0 (maximum fuzzyness) and 1f (no fuzzy matching).
 */
public SPARQLModelIndex(Model model,float minSimilarity)
{
	this.minSimilarity=minSimilarity;
	Dataset ds1 = DatasetFactory.createMem() ;

	EntityDefinition entDef = new EntityDefinition("uri", "text", RDFS.label) ;
	// Lucene, in memory.
	Directory dir =  new RAMDirectory();
	// Join together into a dataset
	dataset = TextDatasetFactory.createLucene(ds1, dir, entDef);
	//		ds.setDefaultModel(model);


	synchronized(model)
	{
		dataset.begin(ReadWrite.WRITE);
		try {
			dataset.getDefaultModel().add(model);
			dataset.commit();
		} finally {
			dataset.end();
		}
	}
	//		this.model = model;
}
 

import org.apache.jena.query.text.EntityDefinition; //导入依赖的package包/类
private Dataset buildDataSet() {
	Dataset ds;
	
	LOGGER.info("Construct a dataset backed by Solr");
	Dataset jenaData = buildBaseDataset();

	if (StringUtils.isNotBlank(jenaConfig.getAssemblerFile())) {
		// The assembler file contains the full mapping detail
		ds = jenaData;
	} else {
		// Define the index mapping
		EntityDefinition entDef = buildEntityDefinition();
		// Define the Solr server
		SolrClient server = new HttpSolrClient(solrConfig.getOntologyUrl());
		// Join together into a dataset
		ds = TextDatasetFactory.create(jenaData, new TextIndexSolr5(server, entDef));
	}
	
	return ds;
}
 

import org.apache.jena.query.text.EntityDefinition; //导入依赖的package包/类
private EntityDefinition buildEntityDefinition() {
	// Build the base definition
	EntityDefinition entity = new EntityDefinition(jenaConfig.getEntityField(), jenaConfig.getPrimaryField());
	
	// And add the field mappings
	for (String field : jenaConfig.getFieldMappings().keySet()) {
		for (String mapping : jenaConfig.getFieldMappings().get(field)) {
			entity.set(field, ResourceFactory.createProperty(mapping).asNode());
		}
	}
	
	return entity;
}
 

import org.apache.jena.query.text.EntityDefinition; //导入依赖的package包/类
private void makeTextDataset() {
    try {
        dir = null;
        if (textIndex == null) {
            log.warn("Opening memory based text index, will not preserved across restarts");
            dir = new RAMDirectory(); 
        } else {
            dir = FSDirectory.open(textIndex);
        }
        EntityDefinition entDef = makeEntityDef();
        dataset = TextDatasetFactory.createLucene(baseDataset, dir, entDef, new StandardAnalyzer(org.apache.jena.query.text.TextIndexLucene.VER)) ;            
    } catch (IOException e) {
        throw new EpiException("Failed to create jena-text lucence index area", e);
    }
}
 

import org.apache.jena.query.text.EntityDefinition; //导入依赖的package包/类
private EntityDefinition makeEntityDef() {
    EntityDefinition entDef = new EntityDefinition("uri", "text", RDFS.label.asNode()) ;
    if (indexSpec != null) {
        for (String spec : indexSpec.split(",")) {
            String uri = Prefixes.getDefault().expandPrefix(spec.trim());
            if ( ! uri.equals("default") ) {
                Node predicate = NodeFactory.createURI(uri);
                if (!predicate.equals(RDFS.label.asNode())) {
                    entDef.set("text", predicate);
                }
            }
        }
    }
    return entDef;
}
 

import org.apache.jena.query.text.EntityDefinition; //导入依赖的package包/类
private Set<Node> getIndexedProperties(EntityDefinition entityDefinition) {
    Set<Node> result = new HashSet<>() ;
    for (String f : entityDefinition.fields()) {
        for ( Node p : entityDefinition.getPredicates(f) )
            result.add(p) ;
    }
    return result ;
}
 

import org.apache.jena.query.text.EntityDefinition; //导入依赖的package包/类
public long textReindex() {
    long count = 0;
    if (textIndex != null || indexSpec != null) {
        DatasetGraphText ds = (DatasetGraphText) dataset.asDatasetGraph();
        ds.getTextIndex().close();

        if (textIndex != null) {
            try {
                org.apache.tomcat.util.http.fileupload.FileUtils.deleteDirectory(textIndex);
            } catch (IOException e) {
                log.warn("Problem deleting old textindex, continuing anyway", e);
            }
        }
        
        makeTextDataset();
        bindFusekiRef();
        ds = (DatasetGraphText) dataset.asDatasetGraph();
        TextIndex index = ds.getTextIndex();
        EntityDefinition entDef = makeEntityDef();
        
        try {
            ds.begin(ReadWrite.READ);
            for ( Node property : getIndexedProperties(entDef) )
            {
                Iterator<Quad> quadIter = ds.find( Node.ANY, Node.ANY, property, Node.ANY );
                for (; quadIter.hasNext(); )
                {
                    Quad quad = quadIter.next();
                    Entity entity = TextQueryFuncs.entityFromQuad( entDef, quad );
                    if ( entity != null )
                    {
                        index.addEntity( entity );
                        count++;
                    }
                }
            }
            index.commit();
        } finally {
            ds.end();
        }
    }
    return count;
}
 

import org.apache.jena.query.text.EntityDefinition; //导入依赖的package包/类
public static void main(String[] args) 
{
	
	TextQuery.init();
	
	Dataset dataset = DatasetFactory.createMem();
	
	EntityDefinition entDef = new EntityDefinition("uri", "text", RDFS.label.asNode()) ;

	// Lucene, in memory.
	Directory dir =  new RAMDirectory();

	// Join together into a dataset
	Dataset ds = TextDatasetFactory.createLucene(dataset, dir, entDef);
	
	
	Model m = ds.getDefaultModel();

	Resource rSubject = m.createResource( "http://ontology.fogbeam.com/example/TestResource1" );
	Resource rSubject2 = m.createResource( "http://ontology.fogbeam.com/example/TestResource2" );
	
	try
	{
	
		Statement s = m.createStatement(rSubject, RDFS.label, "This is a Test Resource" );
	
		m.add( s );
	
		Statement s2 = m.createStatement(rSubject2, RDFS.label, "Bratwurst Test" );
		
		m.add( s2 );
		
		String baseQueryString =
				"PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> " +
				"PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> " +
				"PREFIX dc: <http://purl.org/dc/elements/1.1/> " +
				"PREFIX dcterm: <http://purl.org/dc/terms/> " +
				"PREFIX owl: <http://www.w3.org/2002/07/owl#> " +
				"PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> " +
				"PREFIX text: <http://jena.apache.org/text#>";
					
				
		/* Do a SPARQL query using Jena-Text here... */
		String queryString = baseQueryString + " SELECT * { ?s  text:query( 'Test') ; . ?s rdfs:label ?label . }";
			
			
		Query query = QueryFactory.create(queryString) ;
			
			
		QueryExecution qexec = QueryExecutionFactory.create(query, ds );
		QueryExecUtils.executeQuery(qexec);
		
		m.close();
		
		
	}
	catch( Exception e )
	{
		e.printStackTrace();
	}
	
	System.out.println( "done" );
}