Java METHOD类代码示例

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
/**
 * test that SolrExceptions thrown by HttpSolrServer can
 * correctly encapsulate http status codes even when not on the list of
 * ErrorCodes solr may return.
 */
public void testSolrExceptionCodeNotFromSolr() throws IOException, SolrServerException {
  final int status = 527;
  assertEquals(status + " didn't generate an UNKNOWN error code, someone modified the list of valid ErrorCode's w/o changing this test to work a different way",
               ErrorCode.UNKNOWN, ErrorCode.getErrorCode(status));

  HttpSolrServer server = new HttpSolrServer(jetty.getBaseUrl().toString() +
                                             "/debug/foo");
  try {
    DebugServlet.setErrorCode(status);
    try {
      SolrQuery q = new SolrQuery("foo");
      server.query(q, METHOD.GET);
      fail("Didn't get excepted exception from oversided request");
    } catch (SolrException e) {
      System.out.println(e);
      assertEquals("Unexpected exception status code", status, e.code());
    }
  } finally {
    server.shutdown();
    DebugServlet.clear();
  }
}
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
@Override
public NativeQueryResult executeNativeQuery(Map<String, String[]> parameters) {
    SolrParams params = createSolrParams(parameters);

    try {
        QueryRequest request = new QueryRequest(params, METHOD.POST);
        request.setResponseParser(new InputStreamResponseParser("json"));
        QueryResponse response = request.process(this.solrClient);

        InputStream inputStream = (InputStream) response.getResponse().get("stream");
        if (inputStream != null) {
            return new SolrNativeQueryResult(inputStream);
        }

        return new SolrNativeQueryResult(this.serializeResponse(params, response));
    } catch (SolrException | SolrServerException | IOException e) {
        throw new DataRetrievalException("Could not execute direct query with parameters " + parameters.toString() + ".", e);
    }
}
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
/**
 * Get list of files from the remote Solr server.
 * 
 * @param directoryName
 *            Name of the directory containing the files, or null to fetch a
 *            list of files in top-level directory.
 * @return Map of Solr config files.
 * @throws SophieException
 *             If files cannot be fetched from Solr.
 */
@SuppressWarnings("unchecked")
public static Map<String, Object> getFilesList(String directoryName) throws SophieException {
    ModifiableSolrParams params = new ModifiableSolrParams();
    if (StringUtils.isNotEmpty(directoryName)) {
        params.set("file", directoryName);
    }
    GenericSolrRequest request = new GenericSolrRequest(METHOD.GET, "/admin/file", params);
    try {
        NamedList<Object> response = Sophie.client.request(request);
        NamedList<Object> files = (NamedList<Object>) response.get("files");
        // Wrap in TreeMap so files are sorted by name.
        return new TreeMap<String, Object>(files.asMap(-1));
    } catch (SolrServerException | IOException | SolrException e) {
        throw new SophieException("Unable to fetch list of files in directory " + directoryName, e);
    }
}
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
public RigelConfig(Config applicationConfig) {
    Config config = applicationConfig.getConfig("rigel");

    fieldConfig = Maps.newHashMap();
    Config fields = config.getConfig("field");

    for (String configField : getSubPaths(fields)) {
        Config conf = fields.getConfig(configField);
        FieldConfig f = new FieldConfig(configField, conf.getString("name"));
        fieldConfig.put(configField, f);
    }

    String requestMethod = config.getString("solr.request.method");
    try {
        this.solrRequestMethod = SolrRequest.METHOD.valueOf(requestMethod);
    } catch (IllegalArgumentException e) {
        throw new RuntimeException("rigel.request.method must be either GET or POST");
    }

    this.solrUrl = config.getString("solr.url");
}
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
public static RStreamingExpressionIterator executeStreamingExpression(SolrClient sc, String collection,
    String expression, String[] columnNames) throws IOException, SolrServerException {
    if (!checkResponseWriter(sc)) {
        log.error("The SolrClient's Response Writer should be: " + InputStreamResponseParser.class.getName());
    }
    SolrParams sp = new MapSolrParams(Collections.singletonMap("expr", expression));
    SolrRequest<?> sr = new GenericSolrRequest(METHOD.POST, "/stream", sp);
    NamedList<Object> nl = sc.request(sr, collection);
    InputStream stream = (InputStream) nl.get("stream");
    InputStreamReader reader = new InputStreamReader(stream, "UTF-8");
    if (columnNames == null || columnNames.length == 0) {
        return new RStreamingExpressionIterator(reader);
    }
    return new RStreamingExpressionIterator(reader, columnNames);
}
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
/**
 * Executes a string query.
 * 
 * @param q        a query string.
 * @param numRet   the maximum number of entries to return.  
 * @return a list of documents, an object of the type {@link org.apache.solr.common.SolrDocumentList}. 
 * @throws SolrServerException
 */
public SolrDocumentList runQuery(String q, int numRet)
    throws SolrServerException {
  SolrQuery query = new SolrQuery();
  query.setQuery(q);
  query.setRows(numRet);
  query.setFields("*", "score");
  QueryResponse rsp = mServer.query(query, METHOD.POST);
  return rsp.getResults();
}
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
@Test
public void testTimeout() throws Exception {
  HttpSolrServer server = new HttpSolrServer(jetty.getBaseUrl().toString() +
                                             "/slow/foo");
  SolrQuery q = new SolrQuery("*:*");
  server.setSoTimeout(2000);
  try {
    QueryResponse response = server.query(q, METHOD.GET);
    fail("No exception thrown.");
  } catch (SolrServerException e) {
    assertTrue(e.getMessage().contains("Timeout"));
  }
  server.shutdown();
}
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
@Override
public Object[] getTimeSeries(TimeSeriesDefinition dataDefinition) {
    SolrQuery solrQuery = new SolrQuery(ALL_DOCS_QUERY);
    solrQuery.setRows(0);

    solrQuery.addFilterQuery(FIELD_GLOBAL_AGENT_ID + ":" + escapeSolr(dataDefinition.getGlobalAgentId()));
    solrQuery.addFilterQuery(getTimestampRangeQuery(dataDefinition.getTimeWindow()));
    solrQuery.addFilterQuery(dataDefinition.getPropertyId() + ":*");

    for (String eachFilterQuery : this.createFilterQueries(dataDefinition.getFilter())) {
        solrQuery.addFilterQuery(eachFilterQuery);
    }

    solrQuery.set("json.facet", this.createTimeSeriesFacets(dataDefinition));

    try {
        QueryResponse response = this.solrClient.query(solrQuery, METHOD.POST);

        List<Object> values = new ArrayList<Object>();

        Buckets buckets = Buckets.fromResponse(response, FIELD_TIMESTAMP);
        for (NamedList<Object> eachBucket : buckets) {
            if (dataDefinition.getAggregate() == Aggregate.count) {
                values.add(eachBucket.get(COUNT_FACET_NAME));
            } else {
                values.add(eachBucket.get(AGGREGATION_FACET_NAME));
            }
        }

        return values.toArray();
    } catch (SolrException | SolrServerException | IOException e) {
        throw new DataRetrievalException("Could not retrieve data.", e);
    }
}
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
/**
 * Get content of a file from the remote Solr server.
 *
 * @param fileName
 *            Name of the file to fetch.
 * @return Content of the file.
 * @throws SophieException
 *             If file cannot be fetched from Solr.
 */
public static String getFileContent(String fileName) throws SophieException {
    ModifiableSolrParams params = new ModifiableSolrParams();
    params.set("file", fileName);
    GenericSolrRequest request = new GenericSolrRequest(METHOD.GET, "/admin/file", params);
    request.setResponseParser(new NoOpResponseParser());
    try {
        NamedList<Object> response = Sophie.client.request(request);
        return Objects.toString(response.get("response", 0), "");
    } catch (SolrServerException | IOException | SolrException e) {
        throw new SophieException("Unable to fetch content of file " + fileName, e);
    }
}
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
private void getSolrResults() {
	try {
		QueryResponse response = solrServer.query(solrQuery, METHOD.POST);
		results = response.getResults();
	} catch (SolrServerException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
public ContentRepositoryImpl(SolrServer solr,
        ContentItemFactory contentItemFactory, METHOD method,
        ContentItem.Schema<T> schema) {
    this.solr = checkNotNull(solr);
    this.contentItemFactory = checkNotNull(contentItemFactory);
    this.method = checkNotNull(method);
    this.schema = schema;
}
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
public static Map<String, Object> categoriesAvailable(String catalogId, String categoryId, String productId, 
        String facetPrefix, boolean displayproducts, int viewIndex, int viewSize, List<String> queryFilters, Boolean excludeVariants, String core) {
    // create the data model
    Map<String, Object> result = new HashMap<>();
    HttpSolrClient client = null;
    QueryResponse returnMap = new QueryResponse();
    try {
        // do the basic query
        client = SolrUtil.getHttpSolrClient(core);
        // create Query Object
        String query = "inStock[1 TO *]";
        if (categoryId != null)
            query += " +cat:"+ SolrExprUtil.escapeTermFull(categoryId);
        else if (productId != null)
            query += " +productId:" + SolrExprUtil.escapeTermFull(productId);
        SolrQuery solrQuery = new SolrQuery();
        solrQuery.setQuery(query);

        if (catalogId != null)
            solrQuery.addFilterQuery("+catalog:" + SolrExprUtil.escapeTermFull(catalogId));
        
        if (excludeVariants == null) excludeVariants = SolrProductSearch.excludeVariantsDefault;
        if (excludeVariants)
            SolrProductUtil.addExcludeVariantsFilter(solrQuery);
        
        if (displayproducts) {
            if (viewSize > -1) {
                solrQuery.setRows(viewSize);
            } else
                solrQuery.setRows(50000);
            if (viewIndex > -1) {
                // 2016-04-01: This must be calculated
                //solrQuery.setStart(viewIndex);
                if (viewSize > 0) {
                    solrQuery.setStart(viewSize * viewIndex);
                }
            }
        } else {
            solrQuery.setFields("cat");
            solrQuery.setRows(0);
        }
        
        if(UtilValidate.isNotEmpty(facetPrefix)){
            solrQuery.setFacetPrefix(facetPrefix);
        }
        
        solrQuery.setFacetMinCount(0);
        solrQuery.setFacet(true);
        solrQuery.addFacetField("cat");
        solrQuery.setFacetLimit(-1);
        if (Debug.verboseOn()) Debug.logVerbose("solr: solrQuery: " + solrQuery, module);
        returnMap = client.query(solrQuery,METHOD.POST);
        result.put("rows", returnMap);
        result.put("numFound", returnMap.getResults().getNumFound());
    } catch (Exception e) {
        Debug.logError(e.getMessage(), module);
    }
    return result;
}
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
protected QueryResponse executeQuery(SolrQuery query) throws SolrServerException {
String requestMethod = SolrMeterConfiguration.getProperty(SolrMeterConfiguration.QUERY_METHOD, "GET");
return executor.getSolrServer().query(query, METHOD.valueOf(requestMethod));
 }
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public AgentActivities getAgentActivities(int start, int count, int durationSeconds, int steps, String sort) {
    SolrQuery solrQuery = new SolrQuery(ALL_DOCS_QUERY);
    solrQuery.setRows(0);

    Date endDate = new Date();
    Date startDate = new Date(endDate.getTime() - SECONDS.toMillis(durationSeconds));

    solrQuery.addFilterQuery(getTimestampRangeQuery(startDate, endDate));

    TermsFacet agentFacet = new TermsFacet(FIELD_GLOBAL_AGENT_ID, FIELD_GLOBAL_AGENT_ID);
    agentFacet.setOffset(start);
    agentFacet.setLimit(count);
    agentFacet.setMincount(0);
    agentFacet.setNumBuckets(true);
    agentFacet.setSort(sort);
    agentFacet.addSubFacet(
        new RangeFacet(FIELD_TIMESTAMP, FIELD_TIMESTAMP, startDate, endDate, GapUnit.SECONDS, durationSeconds / steps));

    solrQuery.set("json.facet", FacetList.toJsonString(agentFacet));

    try {
        AgentActivities result = new AgentActivities();

        QueryResponse response = this.solrClient.query(solrQuery, METHOD.POST);

        Buckets agentBuckets = Buckets.fromResponse(response, FIELD_GLOBAL_AGENT_ID);
        result.setOffset(start);
        result.setTotalCount(agentBuckets.getNumBuckets());

        int maxHistoryValue = 0;

        for (NamedList<Object> eachAgentBucket : agentBuckets) {
            AgentActivity agentActivity = new AgentActivity();

            agentActivity.setGlobalAgentId((String) eachAgentBucket.get(VALUE_FACET_NAME));
            agentActivity.setEventCount(Buckets.getInt(eachAgentBucket, COUNT_FACET_NAME));

            int[] history = new int[steps];

            Buckets historyBuckets = Buckets.fromFacet((NamedList<Object>) eachAgentBucket.get(FIELD_TIMESTAMP));
            for (int i = 0; i < Math.min(historyBuckets.getBucketCount(), history.length); i++) {
                NamedList<Object> historyBucket = historyBuckets.getBucket(i);

                int historyValue = Buckets.getInt(historyBucket, COUNT_FACET_NAME);
                history[i] = historyValue;
                maxHistoryValue = Math.max(maxHistoryValue, historyValue);
            }
            agentActivity.setHistory(history);

            result.add(agentActivity);
        }

        result.setMaxHistoryValue(maxHistoryValue);

        return result;
    } catch (SolrException | SolrServerException | IOException e) {
        throw new DataRetrievalException("Could not retrieve Agent activities.", e);
    }
}
 

import org.apache.solr.client.solrj.SolrRequest.METHOD; //导入依赖的package包/类
public QueryResponse query(SolrQuery sq) throws SolrServerException
{
    return server.query(sq, METHOD.POST);
}