Java TermsResponse.getTerms方法代码示例

import org.apache.solr.client.solrj.response.TermsResponse; //导入方法依赖的package包/类
@Override
public List<String> getInstitutions() {
	SolrQuery query = new SolrQuery()
			.addTermsField(INSTITUTIONS_SORT_FIELD)
			.setRequestHandler("/terms").setTerms(true);
	Set<String> institutionsSet = Sets.newTreeSet();
	try {
		QueryResponse response = solrServer.query(query);
		TermsResponse termsResponse = response.getTermsResponse();
		List<Term> termList = termsResponse
				.getTerms(INSTITUTIONS_SORT_FIELD);
		for (Term term : termList) {
			institutionsSet.add(term.getTerm());
		}

	} catch (SolrServerException e) {
		logger.error("Error getting Solr institutions list", e);
		throw new OgpSolrException("Error getting Solr institutions list",
				e);

	}
	return new ArrayList<String>(institutionsSet);
}
 

import org.apache.solr.client.solrj.response.TermsResponse; //导入方法依赖的package包/类
public List<String> complete(String query) {
        List<String> results = new ArrayList<>();

        SolrServer solrServer = new HttpSolrServer("http://" + systemConfig.getSolrHostColonPort() + "/solr");
        SolrQuery solrQuery = new SolrQuery();
        solrQuery.setParam("qt", "/terms");
        solrQuery.setTermsLower(query);
        solrQuery.setTermsPrefix(query);
        // dataverses and files use SearchFields.NAME
//        solrQuery.addTermsField(SearchFields.NAME);
        solrQuery.addTermsField("text");
//        long datasetFieldDescription = 33L;
//        String solrFieldDatasetFieldDescription = datasetFieldService.find(datasetFieldDescription).getSolrField();
//        solrQuery.addTermsField(solrFieldDatasetFieldDescription);
        List<Term> items = null;

        try {
            logger.info("Solr query: " + solrQuery);
            QueryResponse qr = solrServer.query(solrQuery);
            TermsResponse resp = qr.getTermsResponse();
//            items = resp.getTerms(SearchFields.NAME);
            items = resp.getTerms("text");
//            items = resp.getTerms(solrFieldDatasetFieldDescription);
        } catch (SolrServerException e) {
            items = null;
        }

        if (items != null) {
            for (Term term : items) {
                logger.info("term: " + term.getTerm());
                results.add(term.getTerm());
            }
        } else {
            logger.info("no terms found");
        }

        return results;
    }
 

import org.apache.solr.client.solrj.response.TermsResponse; //导入方法依赖的package包/类
private void addTerms( NamedList<NamedList<Number>> terms, SynonymMap.Builder fieldBuilder, SynonymMap.Builder termBuilder, ArrayList<String> searchFields ) throws IOException {
  TermsResponse termsResponse = new TermsResponse( terms );
  for (String fieldName : searchFields ) {
    CharsRef fieldChars = new CharsRef( fieldName );
    List<TermsResponse.Term> termList = termsResponse.getTerms( fieldName );
    if (termList != null) {
      for (TermsResponse.Term tc : termList) {
        String term = tc.getTerm();
        Log.debug( "Add distributed term: " + fieldName + " = " + term );
        addTerm( fieldChars, term, fieldBuilder, termBuilder );
      }
    }
  }
}
 

import org.apache.solr.client.solrj.response.TermsResponse; //导入方法依赖的package包/类
public void parse(NamedList<NamedList<Number>> terms) {
  // exit if there is no terms
  if (terms == null) {
    return;
  }

  TermsResponse termsResponse = new TermsResponse(terms);
  
  // loop though each field and add each term+freq to map
  for (String key : fieldmap.keySet()) {
    HashMap<String, TermsResponse.Term> termmap = fieldmap.get(key);
    List<TermsResponse.Term> termlist = termsResponse.getTerms(key); 

    // skip this field if there are no terms
    if (termlist == null) {
      continue;
    }

    // loop though each term
    for (TermsResponse.Term tc : termlist) {
      String term = tc.getTerm();
      if (termmap.containsKey(term)) {
        TermsResponse.Term oldtc = termmap.get(term);
        oldtc.addFrequency(tc.getFrequency());
        termmap.put(term, oldtc);
      } else {
        termmap.put(term, tc);
      }
    }
  }
}
 

import org.apache.solr.client.solrj.response.TermsResponse; //导入方法依赖的package包/类
public void run( ) {

    try {
      SolrClient solrClient = getSolrClient( );
      if (solrClient == null) {
        LOG.error( "Cant't get SolrClient for " + solrHost );
        return;
      }
        
      if (suggestProcessor == null) {
        LOG.error( "Suggest Processor is NULL!" );
        return;
      }

      ModifiableSolrParams params = new ModifiableSolrParams( );
      
      params.set( TermsParams.TERMS_LIMIT, -1);
      params.set( TermsParams.TERMS_SORT, TermsParams.TERMS_SORT_INDEX);
      String[] fields = termFields.toArray( new String[ termFields.size( )] );
      params.set( TermsParams.TERMS_FIELD, fields );
      params.set( CommonParams.QT, termsHandler );
      params.set( TermsParams.TERMS, "true" );
      
      QueryResponse rsp = solrClient.query( collection, params );
      TermsResponse termsResponse = rsp.getTermsResponse( );
      
      for (String fieldName : termFields ) {

        List<TermsResponse.Term> termList = termsResponse.getTerms( fieldName );
        if (termList != null) {
          for (TermsResponse.Term tc : termList) {
            String term = tc.getTerm();
            HashMap<String,Object> meta = new HashMap<String,Object>( );
            meta.put( "collection", collection );
            meta.put( "collector", "TermVectorQueryCollector" );
            meta.put( "field", fieldName );
          
            QuerySuggestion qSuggestion = new QuerySuggestion( term, meta, null );
            suggestProcessor.addSuggestion( qSuggestion );
          }
        }
      }
    }
    catch ( Exception e ) {
              
    }
    finally {
      suggestProcessor.collectorDone( this );
    }
  }