Java NameUsageMatchingService类代码示例

import org.gbif.api.service.checklistbank.NameUsageMatchingService; //导入依赖的package包/类
@Override
protected void configureClient() {
  // install the 2 private modules that together implement the API
  if (installServiceClients) {
    install(new ChecklistBankWsServiceClientModule());
    expose(NameUsageSearchService.class);
    expose(NameUsageService.class);
    expose(DescriptionService.class);
    expose(DistributionService.class);
    expose(IdentifierService.class);
    expose(MultimediaService.class);
    expose(ReferenceService.class);
    expose(SpeciesProfileService.class);
    expose(TypeSpecimenService.class);
    expose(VernacularNameService.class);
    expose(DatasetMetricsService.class);
  }
  if (installMatchClients) {
    install(new ChecklistBankWsMatchClientModule());
    expose(NameUsageMatchingService.class);
  }
}
 

import org.gbif.api.service.checklistbank.NameUsageMatchingService; //导入依赖的package包/类
@Override
protected void configure() {
  bind(NubMatchingServiceImpl.class).asEagerSingleton();

  bind(NameUsageMatchingService.class).to(NubMatchingServiceImpl.class);
  bind(NameUsageMatchingService2.class).to(NubMatchingServiceImpl.class);

  expose(NameUsageMatchingService.class);
  expose(NameUsageMatchingService2.class);
}
 

import org.gbif.api.service.checklistbank.NameUsageMatchingService; //导入依赖的package包/类
public DeployedNubLookupCorrectnessTest() {
  final String wsProp = "checklistbank.match.ws.url";

  for (String url : WS_URLS) {
    Properties props = new Properties();
    props.setProperty(wsProp, url);

    ChecklistBankWsClientModule mod = new ChecklistBankWsClientModule(props, false, true);
    Injector injector = Guice.createInjector(mod);
    CLIENTS.add(injector.getInstance(NameUsageMatchingService.class));
  }
}
 

import org.gbif.api.service.checklistbank.NameUsageMatchingService; //导入依赖的package包/类
@Inject
public OccurrenceSearchImpl(SolrClient solrClient, @Named(SOLR_REQUEST_HANDLER) String requestHandler,
                            OccurrenceService occurrenceService, NameUsageMatchingService nameUsageMatchingService,
                            @Named("max.offset") int maxOffset, @Named("max.limit") int maxLimit,
                            @Named("facets.enable") boolean facetsEnable) {
  this.solrClient = solrClient;
  occurrenceSearchRequestBuilder = new OccurrenceSearchRequestBuilder(requestHandler, SORT_ORDER,
                                                                      maxOffset, maxLimit, facetsEnable);
  this.occurrenceService = occurrenceService;
  this.nameUsageMatchingService = nameUsageMatchingService;
}
 

import org.gbif.api.service.checklistbank.NameUsageMatchingService; //导入依赖的package包/类
@Override
protected void configureService() {
  install(new SolrModule(solrConfig));
  bind(NameUsageMatchingService.class).toInstance(Mockito.mock(NameUsageMatchingService.class));
  bind(OccurrenceSearchService.class).to(OccurrenceSearchImpl.class);
  expose(OccurrenceSearchService.class);

  // Exposes the SolrClient because it is required to create the index.
  expose(SolrClient.class);
}
 

import org.gbif.api.service.checklistbank.NameUsageMatchingService; //导入依赖的package包/类
public IdLookupWs(Properties props) {
  ChecklistBankWsClientModule module = new ChecklistBankWsClientModule(props, false, true);
  Injector inj = Guice.createInjector(module);
  service = inj.getInstance(NameUsageMatchingService.class);
}
 

import org.gbif.api.service.checklistbank.NameUsageMatchingService; //导入依赖的package包/类
@Override
protected void configure() {

  bind(NameUsageMatchingService.class).to(NubMatchingServiceImpl.class).asEagerSingleton();
  expose(NameUsageMatchingService.class);
}
 

import org.gbif.api.service.checklistbank.NameUsageMatchingService; //导入依赖的package包/类
@Override
protected void configure() {
  bind(NameUsageMatchingService.class).to(NameUsageMatchWsClient.class).in(Scopes.SINGLETON);
}
 

import org.gbif.api.service.checklistbank.NameUsageMatchingService; //导入依赖的package包/类
@Test
public void testMatchingModule() {
  Injector inj = Guice.createInjector(new ChecklistBankWsClientModule(properties, false, true));
  inj.getInstance(NameUsageMatchingService.class);
}
 

import org.gbif.api.service.checklistbank.NameUsageMatchingService; //导入依赖的package包/类
private void testQuery(Integer targetNubId, LinneanClassification cl, String scientificName, String authorship, Rank rank) {

    List<NameUsageMatch> results = Lists.newArrayList();
    for (NameUsageMatchingService client : CLIENTS) {
      NameUsageMatch lookup = null;
      try {
        lookup = client.match(scientificName, rank, cl, false, true);
        results.add(lookup);

        boolean gotMatch;
        if (targetNubId == null) {
          gotMatch = lookup.getUsageKey() == null;
        } else {
          gotMatch = lookup.getUsageKey() != null && lookup.getUsageKey().equals(targetNubId);
        }
        if (rank != null && rank.isSuprageneric()){
          if (lookup.getSpeciesKey()!=null || lookup.getSpecies()!=null){
            System.err.println(
              "Lookup for "+rank.name()+" [" + scientificName +"] contains non null species "+lookup.getSpecies()+" [" + lookup.getSpeciesKey() + "]");
          }
        }
        if (gotMatch) {
          System.out.println(
            "Lookup good for sciName [" + scientificName + "] nubID [" + targetNubId + "] - " + client.toString());
        } else {
          System.err.println(
            "Lookup mismatch for sciName [" + scientificName +"] - wanted [" + targetNubId + "], got [" + (lookup == null ? null : lookup.getUsageKey()) + "] - [" + client.toString() + "]");
        }
      } catch (Exception e) {
        System.err.println("Webservice ERROR: " + e.getMessage());
      }

    }

    for (NameUsageMatch outer : results) {
      if (outer==null) continue;
      for (NameUsageMatch inner : results) {
        if (inner == null) continue;
        if (System.identityHashCode(outer) != System.identityHashCode(inner)) {
          if (!equalLookups(outer, inner)) {
            System.err.println("Results are different from different servers for sciName [" + scientificName + "]");
          }
        }
      }
    }
  }
 

import org.gbif.api.service.checklistbank.NameUsageMatchingService; //导入依赖的package包/类
public NubMatchingServiceTestManual() throws IOException {

    LOG.info("Load clb properties");
    Properties properties = PropertiesUtil.loadProperties("checklistbank.properties");

    LOG.info("Create guice injector");
    Injector inj = Guice.createInjector(new ChecklistBankServiceMyBatisModule(properties), new NubMatchingModule());

    LOG.info("Create matching service");
    matcher = inj.getInstance(NameUsageMatchingService.class);

    LOG.info("Nub Matching setup complete");
  }