Java HttpSolrServer类代码示例

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
private void persistToSolr(Collection<SolrInputDocument> docs) throws SolrServerException, IOException {
    if (docs.isEmpty()) {
        /**
         * @todo Throw an exception here? "DvObject id 9999 does not exist."
         */
        logger.info("nothing to persist");
        return;
    }
    logger.fine("persisting to Solr...");
    SolrServer solrServer = new HttpSolrServer("http://" + systemConfig.getSolrHostColonPort() + "/solr");
    /**
     * @todo Do something with these responses from Solr.
     */
    UpdateResponse addResponse = solrServer.add(docs);
    UpdateResponse commitResponse = solrServer.commit();
}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
public static void main(String[] args) throws MalformedURLException, SolrServerException {
		HttpSolrServer solr = new HttpSolrServer("http://localhost:8983/solr");
//		  ModifiableSolrParams params = new ModifiableSolrParams(); 
//        params.setQuery("name:Samsung ");
//        params.setStart(0);
//        params.setRows(100);
		SolrQuery params = new SolrQuery();
		params.setQuery("*:*");
		params.setSort("score ",ORDER.desc);
		params.setStart(Integer.getInteger("0"));
		params.setRows(Integer.getInteger("100"));

		QueryResponse response = solr.query(params);
		SolrDocumentList results = response.getResults();
		for (int i = 0; i < results.size(); ++i) {
			System.out.println(results.get(i));
		}
	}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
/**
 * 
 * @param indexUrl
 * @return
 */
public static HttpSolrServer getNewHttpSolrServer(String indexUrl) {
    if (indexUrl == null) {
        throw new IllegalArgumentException("indexUrl may not be null");
    }
    HttpSolrServer server = new HttpSolrServer(indexUrl);
    server.setSoTimeout(TIMEOUT_SO); // socket read timeout
    server.setConnectionTimeout(TIMEOUT_CONNECTION);
    server.setDefaultMaxConnectionsPerHost(100);
    server.setMaxTotalConnections(100);
    server.setFollowRedirects(false); // defaults to false
    server.setAllowCompression(true);
    server.setMaxRetries(1); // defaults to 0. > 1 not recommended.
    // server.setParser(new XMLResponseParser()); // binary parser is used by default
    server.setRequestWriter(new BinaryRequestWriter());

    return server;
}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
public long getDatasetCount() throws SearchException{
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*:*");
    solrQuery.setFilterQueries(SearchFields.TYPE+":datasets",
            SearchFields.PUBLICATION_STATUS+":Published");
    solrQuery.setStart(0);
    solrQuery.setRows(0);
    QueryResponse queryResponse = null;
    try {
        queryResponse = solrServer.query(solrQuery);
        return queryResponse.getResults().getNumFound();
    } catch (HttpSolrServer.RemoteSolrException | SolrServerException ex) {  
        logger.log(Level.INFO, null, ex);
        throw new SearchException("Internal Dataverse Search Engine Error", ex);
    }
}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
public long getDataverseCount() throws SearchException{
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*:*");
    solrQuery.setFilterQueries(SearchFields.TYPE+":dataverses",
            SearchFields.PUBLICATION_STATUS+":Published");
    solrQuery.setStart(0);
    solrQuery.setRows(0);
    QueryResponse queryResponse = null;
    try {
        queryResponse = solrServer.query(solrQuery);
        return queryResponse.getResults().getNumFound();
    } catch (HttpSolrServer.RemoteSolrException | SolrServerException ex) {  
        logger.log(Level.INFO, null, ex);
        throw new SearchException("Internal Dataverse Search Engine Error", ex);
    }
}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
public void updateConfiguration() throws SolrServerException, IOException {
    String solrURL = settingDAO.findByKey(SettingKey.SOLR_URL).getConfigurationValue();
    String solrCore = settingDAO.findByKey(SettingKey.SOLR_CORE).getConfigurationValue();
    
    if (!solrURL.endsWith("/")) {
        solrURL = solrURL + "/";
    }
    solrServer = new HttpSolrServer(solrURL + solrCore);
    try {
        
        if (solrServer.ping().getStatus()!=0) {
            throw new SolrServerException("Solr Server not found! ");
        }    
    } catch (HttpSolrServer.RemoteSolrException ex) {
        throw new SolrServerException(ex.getMessage(),ex);
    }
}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
@Override
public SolrServer createNewSolrServer()
{
  try {
    // setup the server...
    String url = jetty.getBaseUrl().toString() + "/collection1";
    HttpSolrServer s = new HttpSolrServer( url );
    s.setConnectionTimeout(DEFAULT_CONNECTION_TIMEOUT);
    s.setDefaultMaxConnectionsPerHost(100);
    s.setMaxTotalConnections(100);
    s.setUseMultiPartPost(random().nextBoolean());

    // where the magic happens
    s.setParser(new BinaryResponseParser());
    s.setRequestWriter(new BinaryRequestWriter());

    return s;
  }
  catch( Exception ex ) {
    throw new RuntimeException( ex );
  }
}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
@Test
public void testArbitraryJsonIndexing() throws Exception  {
  HttpSolrServer server = (HttpSolrServer) getSolrServer();
  server.deleteByQuery("*:*");
  server.commit();
  assertNumFound("*:*", 0); // make sure it got in

  // two docs, one with uniqueKey, another without it
  String json = "{\"id\":\"abc1\", \"name\": \"name1\"} {\"name\" : \"name2\"}";
  HttpClient httpClient = server.getHttpClient();
  HttpPost post = new HttpPost(server.getBaseURL() + "/update/json/docs");
  post.setHeader("Content-Type", "application/json");
  post.setEntity(new InputStreamEntity(new ByteArrayInputStream(json.getBytes("UTF-8")), -1));
  HttpResponse response = httpClient.execute(post);
  assertEquals(200, response.getStatusLine().getStatusCode());
  server.commit();
  assertNumFound("*:*", 2);
}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
@Override
public SolrServer createNewSolrServer() {
  try {
    // setup the server...
    String url = jetty.getBaseUrl().toString() + "/collection1";
    HttpSolrServer s = new HttpSolrServer(url);
    s.setConnectionTimeout(DEFAULT_CONNECTION_TIMEOUT);
    s.setDefaultMaxConnectionsPerHost(100);
    s.setMaxTotalConnections(100);
    s.setUseMultiPartPost(random().nextBoolean());
    
    if (random().nextBoolean()) {
      s.setParser(new BinaryResponseParser());
      s.setRequestWriter(new BinaryRequestWriter());
    }
    
    return s;
  } catch (Exception ex) {
    throw new RuntimeException(ex);
  }
}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
public void testSolrException() throws Throwable {
  // test a connection to a solr server that probably doesn't exist
  // this is a very simple test and most of the test should be considered verified 
  // if the compiler won't let you by without the try/catch
  boolean gotExpectedError = false;
  try {
    // switched to a local address to avoid going out on the net, ns lookup issues, etc.
    // set a 1ms timeout to let the connection fail faster.
    HttpClient httpClient = HttpClientUtil.createClient(null);
    HttpClientUtil.setConnectionTimeout(httpClient,  1);
    SolrServer client = new HttpSolrServer("http://[ff01::114]:11235/solr/", httpClient);
    SolrQuery query = new SolrQuery("test123");
    client.query(query);
    client.shutdown();
  } catch (SolrServerException sse) {
    gotExpectedError = true;
    /***
    assertTrue(UnknownHostException.class == sse.getRootCause().getClass()
            //If one is using OpenDNS, then you don't get UnknownHostException, instead you get back that the query couldn't execute
            || (sse.getRootCause().getClass() == SolrException.class && ((SolrException) sse.getRootCause()).code() == 302 && sse.getMessage().equals("Error executing query")));
    ***/
  }
  assertTrue(gotExpectedError);
}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
@Override
public SolrServer createNewSolrServer() {
  try {
    String url = jetty.getBaseUrl().toString() + "/collection1";
    HttpSolrServer s = new HttpSolrServer(url);
    s.setUseMultiPartPost(random().nextBoolean());
    s.setConnectionTimeout(DEFAULT_CONNECTION_TIMEOUT);
    s.setDefaultMaxConnectionsPerHost(100);
    s.setMaxTotalConnections(100);
    s.setParser(new XMLResponseParser());
    s.setRequestWriter(new RequestWriter());
    return s;
  } catch (Exception ex) {
    throw new RuntimeException(ex);
  }
}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
private void addDocs(SolrInstance solrInstance) throws IOException, SolrServerException {
  List<SolrInputDocument> docs = new ArrayList<>();
  for (int i = 0; i < 10; i++) {
    SolrInputDocument doc = new SolrInputDocument();
    doc.addField("id", i);
    doc.addField("name", solrInstance.name);
    docs.add(doc);
  }
  HttpSolrServer solrServer = new HttpSolrServer(solrInstance.getUrl(), httpClient);
  SolrResponseBase resp;
  try {
    resp = solrServer.add(docs);
    assertEquals(0, resp.getStatus());
    resp = solrServer.commit();
  } finally {
    solrServer.shutdown();
  }
  assertEquals(0, resp.getStatus());
}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
/**
 * Create a new solr server.
 * If createJetty was called, an http implementation will be created,
 * otherwise an embedded implementation will be created.
 * Subclasses should override for other options.
 */
public SolrServer createNewSolrServer() {
  if (jetty != null) {
    try {
      // setup the server...
      String url = jetty.getBaseUrl().toString() + "/" + "collection1";
      HttpSolrServer s = new HttpSolrServer( url );
      s.setConnectionTimeout(DEFAULT_CONNECTION_TIMEOUT);
      s.setDefaultMaxConnectionsPerHost(100);
      s.setMaxTotalConnections(100);
      return s;
    }
    catch( Exception ex ) {
      throw new RuntimeException( ex );
    }
  } else {
    return new EmbeddedSolrServer( h.getCoreContainer(), "" );
  }
}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
public  static void waitForNon403or404or503(HttpSolrServer collectionClient)
    throws Exception {
  SolrException exp = null;
  long timeoutAt = System.currentTimeMillis() + 30000;

  while (System.currentTimeMillis() < timeoutAt) {
    boolean missing = false;

    try {
      collectionClient.query(new SolrQuery("*:*"));
    } catch (SolrException e) {
      if (!(e.code() == 403 || e.code() == 503 || e.code() == 404)) {
        throw e;
      }
      exp = e;
      missing = true;
    }
    if (!missing) {
      return;
    }
    Thread.sleep(50);
  }

  fail("Could not find the new collection - " + exp.code() + " : " + collectionClient.getBaseURL());
}
 

import org.apache.solr.client.solrj.impl.HttpSolrServer; //导入依赖的package包/类
protected NamedList<Object> invokeCollectionApi(String... args) throws SolrServerException, IOException {
  ModifiableSolrParams params = new ModifiableSolrParams();
  SolrRequest request = new QueryRequest(params);
  for (int i = 0; i < args.length - 1; i+=2) {
    params.add(args[i], args[i+1]);
  }
  request.setPath("/admin/collections");

  String baseUrl = ((HttpSolrServer) shardToJetty.get(SHARD1).get(0).client.solrClient)
      .getBaseURL();
  baseUrl = baseUrl.substring(0, baseUrl.length() - "collection1".length());

  HttpSolrServer baseServer = new HttpSolrServer(baseUrl);
  baseServer.setConnectionTimeout(15000);
  baseServer.setSoTimeout(60000 * 5);
  NamedList r = baseServer.request(request);
  baseServer.shutdown();
  return r;
}