How to use com.netflix.hystrix.contrib.javanica.command

/**
 * Constructor with parameters.
 *
 * @param metaHolder the {@link MetaHolder}
 */
public CommandCollapser(MetaHolder metaHolder) {
  super(HystrixCommandBuilderFactory.getInstance().create(metaHolder).getSetterBuilder().buildCollapserCommandSetter());
  this.metaHolder = metaHolder;
}

  public HystrixInvokable createDelayed(MetaHolder metaHolder) {
    HystrixInvokable executable;
    if (metaHolder.isObservable()) {
      executable = new GenericObservableCommand(HystrixCommandBuilderFactory.getInstance().create(metaHolder));
    } else {
      executable = new GenericCommand(HystrixCommandBuilderFactory.getInstance().create(metaHolder));
    }
    return executable;
  }
}

private CommandActions createCommandActions(MetaHolder metaHolder) {
  CommandAction commandAction = createCommandAction(metaHolder);
  CommandAction fallbackAction = createFallbackAction(metaHolder);
  return CommandActions.builder().commandAction(commandAction)
      .fallbackAction(fallbackAction).build();
}

public <ResponseType> HystrixCommandBuilder create(MetaHolder metaHolder, Collection<HystrixCollapser.CollapsedRequest<ResponseType, Object>> collapsedRequests) {
  validateMetaHolder(metaHolder);
  return HystrixCommandBuilder.builder()
      .setterBuilder(createGenericSetterBuilder(metaHolder))
      .commandActions(createCommandActions(metaHolder))
      .collapsedRequests(collapsedRequests)
      .cacheResultInvocationContext(createCacheResultInvocationContext(metaHolder))
      .cacheRemoveInvocationContext(createCacheRemoveInvocationContext(metaHolder))
      .ignoreExceptions(metaHolder.getCommandIgnoreExceptions())
      .executionType(metaHolder.getExecutionType())
      .build();
}

protected AbstractHystrixCommand(HystrixCommandBuilder builder) {
  super(builder.getSetterBuilder().build());
  this.commandActions = builder.getCommandActions();
  this.collapsedRequests = builder.getCollapsedRequests();
  this.cacheResultInvocationContext = builder.getCacheResultInvocationContext();
  this.cacheRemoveInvocationContext = builder.getCacheRemoveInvocationContext();
  this.ignoreExceptions = builder.getIgnoreExceptions();
  this.executionType = builder.getExecutionType();
}

public GenericObservableCommand(HystrixCommandBuilder builder) {
  super(builder.getSetterBuilder().buildObservableCommandSetter());
  this.commandActions = builder.getCommandActions();
  this.cacheResultInvocationContext = builder.getCacheResultInvocationContext();
  this.cacheRemoveInvocationContext = builder.getCacheRemoveInvocationContext();
  this.ignoreExceptions = builder.getIgnoreExceptions();
  this.executionType = builder.getExecutionType();
}

/**
 * {@inheritDoc}
 */
@Override
public Object execute(ExecutionType executionType) throws CommandActionExecutionException {
  HystrixInvokable command = HystrixCommandFactory.getInstance().createDelayed(createCopy(originalMetaHolder, executionType));
  return new CommandExecutionAction(command, originalMetaHolder).execute(executionType);
}

  @Override
  Object execute() {
    MetaHolder metaHolder = commandAction.getMetaHolder();
    Object[] args = toArgs(getCollapsedRequests());
    args = createArgsForFallback(args, metaHolder, getExecutionException());
    return commandAction.executeWithArgs(commandAction.getMetaHolder().getFallbackExecutionType(), args);
  }
});

private CommandAction createCommandAction(MetaHolder metaHolder) {
  return new MethodExecutionAction(metaHolder.getObj(), metaHolder.getMethod(), metaHolder.getArgs(), metaHolder);
}

  @Override
  Object execute() {
    MetaHolder metaHolder = commandAction.getMetaHolder();
    Object[] args = createArgsForFallback(metaHolder, getExecutionException());
    return commandAction.executeWithArgs(metaHolder.getFallbackExecutionType(), args);
  }
});

/**
 * Creates batch command.
 */
@Override
protected HystrixCommand<List<Object>> createCommand(
    Collection<CollapsedRequest<Object, Object>> collapsedRequests) {
  return new BatchHystrixCommand(HystrixCommandBuilderFactory.getInstance().create(metaHolder, collapsedRequests));
}

  @Override
  Object execute() {
    return getCommandAction().executeWithArgs(getExecutionType(), args);
  }
});

  @Override
  Object execute() {
    return getCommandAction().execute(getExecutionType());
  }
});

private Object process(final Object[] args) throws Exception {
  return process(new Action() {
    @Override
    Object execute() {
      return getCommandAction().executeWithArgs(getExecutionType(), args);
    }
  });
}

/**
 * {@inheritDoc}
 */
@Override
public Object getRequestArgument() {
  return metaHolder.getArgs();
}

  /**
   * Creates new {@link HystrixCommandBuilder} instance.
   *
   * @return new {@link HystrixCommandBuilder} instance
   */
  public HystrixCommandBuilder build() {
    return new HystrixCommandBuilder(this);
  }
}

/**
 * Gets fallback action.
 *
 * @return fallback action
 */
protected CommandAction getFallbackAction() {
  return commandActions.getFallbackAction();
}

/**
 * Gets command action.
 *
 * @return command action
 */
protected CommandAction getCommandAction() {
  return commandActions.getCommandAction();
}

public HystrixInvokable create(MetaHolder metaHolder) {
  HystrixInvokable executable;
  if (metaHolder.isCollapserAnnotationPresent()) {
    executable = new CommandCollapser(metaHolder);
  } else if (metaHolder.isObservable()) {
    executable = new GenericObservableCommand(HystrixCommandBuilderFactory.getInstance().create(metaHolder));
  } else {
    executable = new GenericCommand(HystrixCommandBuilderFactory.getInstance().create(metaHolder));
  }
  return executable;
}

/**
 * {@inheritDoc}
 */
@Override
public Object executeWithArgs(ExecutionType executionType, Object[] args) throws CommandActionExecutionException {
  HystrixInvokable command = HystrixCommandFactory.getInstance().createDelayed(createCopy(originalMetaHolder, executionType, args));
  return new CommandExecutionAction(command, originalMetaHolder).execute(executionType);
}