Java Bulk类代码示例

import io.searchbox.core.Bulk; //导入依赖的package包/类
@Test
public void configReturnsACopyOfServerUrisList() {

    // given
    Builder builder = createTestObjectFactoryBuilder();
    builder.withServerUris("http://localhost:9200;http://localhost:9201;http://localhost:9202");
    ClientObjectFactory<JestClient, Bulk> config = builder.build();

    // when
    Collection<String> serverUrisList = config.getServerList();
    serverUrisList.add("test");

    // then
    assertNotEquals(serverUrisList.size(), config.getServerList().size());

}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
@Override
public Function<Bulk, Boolean> createBatchListener(FailoverPolicy failoverPolicy) {
    return new Function<Bulk, Boolean>() {

        private Function<Bulk, Boolean> failureHandler = createFailureHandler(failoverPolicy);
        private JestClient client = createClient();

        @Override
        public Boolean apply(Bulk bulk) {
            JestResultHandler<JestResult> jestResultHandler = createResultHandler(bulk, failureHandler);
            client.executeAsync(bulk, jestResultHandler);
            return true;
        }

    };
}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
@Override
public BatchBuilder<Bulk> createBatchBuilder() {
    return new BatchBuilder<Bulk>() {

        private final Bulk.Builder builder = new Bulk.Builder();

        @Override
        public void add(Object item) {
            builder.addAction((BulkableAction)item);
        }

        @Override
        public Bulk build() {
            return builder.build();
        }
    };
}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
@Test
public void failureHandlerExecutesFailoverForEachBatchItemSeparately() {

    // given
    Builder builder = createTestObjectFactoryBuilder();
    ClientObjectFactory<JestClient, Bulk> config = builder.build();

    FailoverPolicy failoverPolicy = Mockito.spy(new NoopFailoverPolicy());

    String payload1 = "test1";
    String payload2 = "test2";
    Bulk bulk = new Bulk.Builder()
            .addAction(spy(new Index.Builder(payload1)).build())
            .addAction(spy(new Index.Builder(payload2)).build())
            .build();

    // when
    config.createFailureHandler(failoverPolicy).apply(bulk);

    // then
    ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
    verify(failoverPolicy, times(2)).deliver((String) captor.capture());

    assertTrue(captor.getAllValues().contains(payload1));
    assertTrue(captor.getAllValues().contains(payload2));
}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
@Test
public void clientIsCalledWhenListenerIsNotified() {

    // given
    Builder builder = createTestObjectFactoryBuilder();
    ClientObjectFactory<JestClient, Bulk> config = spy(builder.build());

    JestClient mockedJestClient = mock(JestClient.class);
    when(config.createClient()).thenReturn(mockedJestClient);

    FailoverPolicy failoverPolicy = spy(new NoopFailoverPolicy());
    Function<Bulk, Boolean> listener = config.createBatchListener(failoverPolicy);

    String payload1 = "test1";
    String payload2 = "test2";
    Bulk bulk = createTestBatch(payload1, payload2);

    // when
    listener.apply(bulk);

    // then
    ArgumentCaptor<Bulk> captor = ArgumentCaptor.forClass(Bulk.class);
    verify(mockedJestClient, times(1)).executeAsync((Bulk) captor.capture(), Mockito.any());

    assertEquals(bulk, captor.getValue());
}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
@Test
public void failoverIsExecutedAfterNonSuccessfulRequest() {

    // given
    Builder builder = createTestObjectFactoryBuilder();
    JestHttpObjectFactory config = spy(builder.build());

    String payload1 = "test1";
    String payload2 = "test2";
    Bulk bulk = createTestBatch(payload1, payload2);

    Function<Bulk, Boolean> failoverHandler = mock(Function.class);
    JestResultHandler<JestResult> resultHandler = config.createResultHandler(bulk, failoverHandler);

    JestResult result = mock(JestResult.class);
    when(result.isSucceeded()).thenReturn(false);

    // when
    resultHandler.completed(result);

    // then
    ArgumentCaptor<Bulk> captor = ArgumentCaptor.forClass(Bulk.class);
    verify(failoverHandler, times(1)).apply(captor.capture());

    assertEquals(bulk, captor.getValue());
}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
@Test
public void failoverIsNotExecutedAfterSuccessfulRequest() {

    // given
    Builder builder = createTestObjectFactoryBuilder();
    JestHttpObjectFactory config = spy(builder.build());

    String payload1 = "test1";
    String payload2 = "test2";
    Bulk bulk = createTestBatch(payload1, payload2);

    Function<Bulk, Boolean> failoverHandler = mock(Function.class);
    JestResultHandler<JestResult> resultHandler = config.createResultHandler(bulk, failoverHandler);

    JestResult result = mock(JestResult.class);
    when(result.isSucceeded()).thenReturn(true);

    // when
    resultHandler.completed(result);

    // then
    verify(failoverHandler, never()).apply(Mockito.any(Bulk.class));
}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
@Test
public void failoverIsExecutedAfterFailedRequest() {

    // given
    Builder builder = createTestObjectFactoryBuilder();
    JestHttpObjectFactory config = spy(builder.build());

    String payload1 = "test1";
    String payload2 = "test2";
    Bulk bulk = createTestBatch(payload1, payload2);

    Function<Bulk, Boolean> failoverHandler = mock(Function.class);
    JestResultHandler<JestResult> resultHandler = config.createResultHandler(bulk, failoverHandler);

    // when
    resultHandler.failed(new IOException());

    // then
    ArgumentCaptor<Bulk> captor = ArgumentCaptor.forClass(Bulk.class);
    verify(failoverHandler, times(1)).apply(captor.capture());

    assertEquals(bulk, captor.getValue());
}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
/**
 * Execute locked items from the MongoDB Queue Repository.
 * 
 * @param lockedItems A list of locked queues items.
 */
private void executeQueueItemActions(List<ElasticsearchUpdateQueueItem> lockedItems) {
  Bulk.Builder bulkBuilder = new Bulk.Builder();
  for (ElasticsearchUpdateQueueItem lockedItem : lockedItems) {
    switch (lockedItem.getAction()) {
      case DELETE:
        addDeleteActions(lockedItem, bulkBuilder);
        break;
      case UPSERT:
        addUpsertActions(lockedItem, bulkBuilder);
        break;
      default:
        throw new NotImplementedException("Processing queue item with action "
            + lockedItem.getAction() + " has not been implemented!");
    }
  }

  // execute the bulk update/delete
  elasticsearchDao.executeBulk(bulkBuilder.build());

  // finally delete the queue items
  queueItemRepository.delete(lockedItems);
}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
@Override
public void replace(InternalGroup group) throws IOException {
  Bulk bulk =
      new Bulk.Builder()
          .defaultIndex(indexName)
          .defaultType(GROUPS)
          .addAction(insert(GROUPS, group))
          .refresh(true)
          .build();
  JestResult result = client.execute(bulk);
  if (!result.isSucceeded()) {
    throw new IOException(
        String.format(
            "Failed to replace group %s in index %s: %s",
            group.getGroupUUID().get(), indexName, result.getErrorMessage()));
  }
}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
@Override
public void replace(AccountState as) throws IOException {
  Bulk bulk =
      new Bulk.Builder()
          .defaultIndex(indexName)
          .defaultType(ACCOUNTS)
          .addAction(insert(ACCOUNTS, as))
          .refresh(true)
          .build();
  JestResult result = client.execute(bulk);
  if (!result.isSucceeded()) {
    throw new IOException(
        String.format(
            "Failed to replace account %s in index %s: %s",
            as.getAccount().getId(), indexName, result.getErrorMessage()));
  }
}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
@Override
public void replace(ProjectData projectState) throws IOException {
  Bulk bulk =
      new Bulk.Builder()
          .defaultIndex(indexName)
          .defaultType(PROJECTS)
          .addAction(insert(PROJECTS, projectState))
          .refresh(true)
          .build();
  JestResult result = client.execute(bulk);
  if (!result.isSucceeded()) {
    throw new IOException(
        String.format(
            "Failed to replace project %s in index %s: %s",
            projectState.getProject().getName(), indexName, result.getErrorMessage()));
  }
}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
@Override
public <T extends Document> void deleteDocuments(Collection<T> documents) throws Exception {
    final Builder bulkBuilder = new Bulk.Builder();
    bulkBuilder.defaultIndex(Constants.INDEX);
    
    for (Document d : documents){
        bulkBuilder.addAction(new Delete.Builder(d.getUUID().toString())
        .index(Constants.INDEX)
        .type(d.getType().toString()).build());
    }
    
    runESOperation(new ESOperation<Void>() {

        @Override
        public Void run() throws Exception {
            conn.execute(bulkBuilder.build());
            return null;
        }
    });
}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
@Override
public <T extends Document> void saveDocuments(Collection<T> documents) throws Exception {
    final Builder bulkBuilder = new Bulk.Builder();
    for (Document d : documents){
        bulkBuilder.addAction(new Index.Builder(d)
        .index(Constants.INDEX)
        .type(d.getType().toString())
        .id(d.getUUID().toString()).build());
    }
    
    runESOperation(new ESOperation<Void>() {

        @Override
        public Void run() throws Exception {
            conn.execute(bulkBuilder.build());
            return null;
        }
    });
    
}
 

import io.searchbox.core.Bulk; //导入依赖的package包/类
public void builderIndex_Bulk(List<Entity> entityList, boolean cleanBeforeInsert) {
  int nRecords = entityList.size();
  long start = System.currentTimeMillis();
  try {
    if (cleanBeforeInsert) {
      jestHttpClient.execute(new DeleteIndex(new DeleteIndex.Builder(_esIndexName)));
    }
    JestResult jestResult = jestHttpClient.execute(new IndicesExists.Builder(_esIndexName).build());
    if (!jestResult.isSucceeded()) {
      jestHttpClient.execute(new CreateIndex.Builder(_esIndexName).build());
    }


    SerializeBeans2JSON sb2json = new SerializeBeans2JSON(); 
    Bulk.Builder bulkBuilder = new Bulk.Builder();
    for (int i = 0; i < nRecords; i++) {
      Index index = new Index
          .Builder(sb2json.serializeBeans2JSON(entityList.get(i)))
      .index(_esIndexName)
      .type(_esTypeName)
      .id(entityList.get(i).getEntityID())
      .build();
      bulkBuilder.addAction(index);
    }
    jestHttpClient.execute(bulkBuilder.build());
  } catch (Exception e) {
    e.printStackTrace();
  }
  long end = System.currentTimeMillis();
  LOG.info("->> Bulk: total time for create index --> " + (end - start) + " milliseconds, # of records: " + nRecords); 
}