Java HystrixCommand类代码示例

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
@Test
public void testCommandToPublisher() throws Exception {
    // Given
    HystrixCommand<InputStream> command = new InputStreamTestCommand();
    final Publisher<CommandHelperTestData> publisher = CommandHelper.toPublisher(CommandHelperTestData.class, mapper,
            command);
    final List<CommandHelperTestData> receivedData = new ArrayList<>();

    // When
    Flux.from(publisher).subscribe(receivedData::add);

    // Then
    assertEquals(3, receivedData.size());
    assertEquals("1", receivedData.get(0).getValue());
    assertEquals("2", receivedData.get(1).getValue());
    assertEquals("3", receivedData.get(2).getValue());
}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
@RequestMapping(value = "/api/datasets/{datasetId}/column/{columnId}", method = POST, consumes = APPLICATION_JSON_VALUE)
@ApiOperation(value = "Update a dataset.", consumes = APPLICATION_JSON_VALUE, //
        notes = "Update a data set based on content provided in POST body with given id. For documentation purposes, body is typed as 'text/plain' but operation accepts binary content too.")
@Timed
public void updateColumn(@PathVariable(value = "datasetId") @ApiParam(value = "Id of the dataset to update") final String datasetId,
                         @PathVariable(value = "columnId") @ApiParam(value = "Id of the column to update") final String columnId,
                         @ApiParam(value = "content") final InputStream body) {

    if (LOG.isDebugEnabled()) {
        LOG.debug("Creating or updating dataset #{} (pool: {})...", datasetId, getConnectionStats());
    }

    final HystrixCommand<Void> creation = getCommand(UpdateColumn.class, datasetId, columnId, body);
    creation.execute();

    LOG.debug("Dataset creation or update for #{} done.", datasetId);
}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
@Override
public HystrixCommand<T> execute(EndpointCall<R> call, Object[] args) {
	return new HystrixCommand<T>(hystrixMetadata()) {
		@Override
		protected T run() throws Exception {
			return delegate.execute(call, args);
		}

		protected T getFallback() {
			return fallback == null ? super.getFallback() : doFallback();
		}

		private T doFallback() {
			HystrixCommandFallback hystrixCommandFallback = Optional.ofNullable(fallback)
					.map(f -> new HystrixCommandFallback(endpointMethod, args, fallback))
						.orElse(null);

			HystrixCommand<T> value = hystrixCommandFallback.run();
			return value.execute();
		};
	};
}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
/**
 * [SLEUTH] TraceCommand
 */
@Override
public void bottle(Wort wort, String processId, String testCommunicationType) {
    log.info("I'm in the bottling service");
    log.info("Process ID from headers {}", processId);
    String groupKey = "bottling";
    String commandKey = "bottle";
    HystrixCommand.Setter setter = HystrixCommand.Setter
            .withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey))
            .andCommandKey(HystrixCommandKey.Factory.asKey(commandKey));
    TestConfigurationHolder testConfigurationHolder = TestConfigurationHolder.TEST_CONFIG.get();
    new TraceCommand<Void>(tracer, traceKeys, setter) {
        @Override
        public Void doRun() throws Exception {
            TestConfigurationHolder.TEST_CONFIG.set(testConfigurationHolder);
            log.info("Sending info to bottling service about process id [{}]", processId);
            bottlerService.bottle(wort, processId);
            return null;
        }
    }.execute();
}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
@RequestMapping(value = "/api/mail", method = PUT)
@ApiOperation(value = "Send feedback to Talend")
@Timed
public void mailTo(@RequestBody MailDetails mailDetails) {
    if (mailDetails.isEmpty()) {
        throw new TDPException(APIErrorCodes.UNABLE_TO_GET_MAIL_DETAILS);
    }
    try {

        final HystrixCommand<Void> sendFeedback = getCommand(MailToCommand.class, mailDetails);
        sendFeedback.execute();

    } catch (Exception e) {
        throw new TDPException(APIErrorCodes.UNABLE_TO_SEND_MAIL, e);
    }

}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
/**
 * Create a dataset from request body content.
 *
 * @param name           The dataset name.
 * @param contentType    the request content type used to distinguish dataset creation or import.
 * @param dataSetContent the dataset content from the http request body.
 * @return The dataset id.
 */
@RequestMapping(value = "/api/datasets", method = POST, produces = TEXT_PLAIN_VALUE)
@ApiOperation(value = "Create a data set", produces = TEXT_PLAIN_VALUE, notes = "Create a new data set based on content provided in POST body. For documentation purposes, body is typed as 'text/plain' but operation accepts binary content too. Returns the id of the newly created data set.")
@Timed
public Callable<String> create(
        @ApiParam(value = "User readable name of the data set (e.g. 'Finance Report 2015', 'Test Data Set').") @RequestParam(defaultValue = "", required = false) String name,
        @ApiParam(value = "An optional tag to be added in data set metadata once created.") @RequestParam(defaultValue = "", required = false) String tag,
        @ApiParam(value = "Size of the data set, in bytes.") @RequestParam(defaultValue = "0") long size,
        @RequestHeader(CONTENT_TYPE) String contentType, @ApiParam(value = "content") InputStream dataSetContent) {
    return () -> {
        if (LOG.isDebugEnabled()) {
            LOG.debug("Creating dataset (pool: {} )...", getConnectionStats());
        }
        try {
            HystrixCommand<String> creation = getCommand(CreateDataSet.class, name, tag, contentType, size, dataSetContent);
            return creation.execute();
        } finally {
            LOG.debug("Dataset creation done.");
        }
    };
}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
@RequestMapping(value = "/api/datasets/{id}", method = POST, produces = TEXT_PLAIN_VALUE)
@ApiOperation(value = "Update a dataset.", produces = TEXT_PLAIN_VALUE, //
        notes = "Update a data set based on content provided in POST body with given id. For documentation purposes, body is typed as 'text/plain' but operation accepts binary content too.")
@Timed
public Callable<String> update(@ApiParam(value = "Id of the data set to update / create") @PathVariable(value = "id") String id,
                     @ApiParam(value = "content") InputStream dataSetContent) {
    return () -> {
        if (LOG.isDebugEnabled()) {
            LOG.debug("Creating or updating dataset #{} (pool: {})...", id, getConnectionStats());
        }
        HystrixCommand<String> creation = getCommand(UpdateDataSet.class, id, dataSetContent);
        String result = creation.execute();
        LOG.debug("Dataset creation or update for #{} done.", id);
        return result;
    };
}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
@Bean
public SetterFactory commandKeyIsRequestLineSetterFactory() {
	return new SetterFactory() {
		@Override public HystrixCommand.Setter create(Target<?> target,
			Method method) {
			String groupKey = SETTER_PREFIX + target.name();
			RequestMapping requestMapping = method
				.getAnnotation(RequestMapping.class);
			String commandKey =
				SETTER_PREFIX + requestMapping.method()[0] + " " + requestMapping
					.path()[0];
			return HystrixCommand.Setter
				.withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey))
				.andCommandKey(HystrixCommandKey.Factory.asKey(commandKey));
		}
	};
}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
@Test
public void testHystrixSetterFactory() {
	HystrixCommand<List<Hello>> command = this.hystrixSetterFactoryClient
		.getHellosHystrix();
	assertNotNull("command was null", command);
	String setterPrefix = TestHystrixSetterFactoryClientConfig.SETTER_PREFIX;
	assertEquals(
		"Hystrix command group name should match the name of the feign client with a prefix of "
			+ setterPrefix, setterPrefix + "localapp5",
		command.getCommandGroup().name());
	assertEquals(
		"Hystrix command key name should match the request method (space) request path with a prefix of "
			+ setterPrefix, setterPrefix + "GET /hellos",
		command.getCommandKey().name());
	List<Hello> hellos = command.execute();
	assertNotNull("hellos was null", hellos);
	assertEquals("hellos didn't match", hellos, getHelloList());
}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
@Test
public void itShouldCreateDeviceCertificateSuccessfully() {
    DeviceCertClient sut = Clients.simpleDeviceCertClient(BASE_ENDPOINT);

    CreateDeviceCertificateRequestDto request = CreateDeviceCertificateRequestDto.builder()
            .devicePublicKey(ANY_PUBLIC_KEY)
            .build();

    HystrixCommand<CreateDeviceCertificateResponseDto> deviceCertificateRequest = sut
            .createDeviceCertificate(DEMO_APP_ID, DEMO_API_KEY, request);

    CreateDeviceCertificateResponseDto deviceCertificateResponse = deviceCertificateRequest.execute();

    assertThat(deviceCertificateResponse, is(notNullValue()));
}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
@Test
public void itShouldCreateDeviceCertificateSuccessfully() throws JsonProcessingException {
    CreateDeviceCertificateResponseDto deviceCertificate = CreateDeviceCertificateResponseDtoObjectMother.random();
    String deviceCertificateAsJson = Clients.defaultObjectMapper.writeValueAsString(deviceCertificate);

    MockClient mockClient = new MockClient()
            .add(HttpMethod.POST, "/api/v1/device_certificates", Response.builder()
                    .status(HttpStatus.CREATED.value())
                    .reason(HttpStatus.CREATED.getReasonPhrase())
                    .headers(Collections.<String, Collection<String>>emptyMap())
                    .body(deviceCertificateAsJson, Charsets.UTF_8));

    Target<DeviceCertClient> mockTarget = new MockTarget<DeviceCertClient>(DeviceCertClient.class);

    DeviceCertClient sut = Clients.simpleFeignBuilder()
            .client(mockClient)
            .build()
            .newInstance(mockTarget);

    CreateDeviceCertificateRequestDto request = CreateDeviceCertificateRequestDto.builder()
            .build();

    HystrixCommand<CreateDeviceCertificateResponseDto> deviceCertificateRequest = sut
            .createDeviceCertificate(RANDOM_APP_ID, RANDOM_API_KEY, request);

    CreateDeviceCertificateResponseDto deviceCertificateResponse = deviceCertificateRequest.execute();

    assertThat(deviceCertificateResponse, is(notNullValue()));
    assertThat(deviceCertificateResponse.getDeviceCertificate(), is(deviceCertificate.getDeviceCertificate()));
}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
@Test
public void itShouldFetchAccessCertificatesSuccessfully() throws JsonProcessingException {
    GetAccessCertificatesResponseDto accessCertificatesResponseDto = GetAccessCertificatesResponseDtoObjectMother.random();
    String accessCertificatesResponseDtoAsJson = Clients.defaultObjectMapper.writeValueAsString(accessCertificatesResponseDto);

    MockClient mockClient = new MockClient()
            .add(HttpMethod.GET, String.format("/api/v1/device/%s/access_certificates", RANDOM_DEVICE_SERIAL), Response.builder()
                    .status(HttpStatus.OK.value())
                    .reason(HttpStatus.OK.getReasonPhrase())
                    .headers(Collections.<String, Collection<String>>emptyMap())
                    .body(accessCertificatesResponseDtoAsJson, Charsets.UTF_8));

    Target<AccessCertClient> mockTarget = new MockTarget<AccessCertClient>(AccessCertClient.class);

    AccessCertClient sut = Clients.simpleFeignBuilder()
            .client(mockClient)
            .build()
            .newInstance(mockTarget);

    HystrixCommand<GetAccessCertificatesResponseDto> accessCertificatesRequest = sut
            .fetchAccessCertificates("", "", RANDOM_DEVICE_SERIAL);

    GetAccessCertificatesResponseDto accessCertificatesResponse = accessCertificatesRequest.execute();

    assertThat(accessCertificatesResponse, is(notNullValue()));
    assertThat(accessCertificatesResponse, is(accessCertificatesResponseDto));
    assertThat(accessCertificatesResponse.getAccessCertificates(), hasSize(accessCertificatesResponseDto.getAccessCertificates().size()));
}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
private static Setter setter() {
    HystrixCommandGroupKey groupkey = HystrixCommandGroupKey.Factory.asKey("rpc");
    HystrixCommandKey commandkey = HystrixCommandKey.Factory.asKey("say");
    HystrixThreadPoolKey threadpoolkey = HystrixThreadPoolKey.Factory.asKey("hello-1");
    HystrixThreadPoolProperties.Setter threadproperties = HystrixThreadPoolProperties.Setter()//
                    .withCoreSize(20).withKeepAliveTimeMinutes(5).withMaxQueueSize(1000).withQueueSizeRejectionThreshold(100);

    HystrixCommandProperties.Setter commandproperty = HystrixCommandProperties.Setter()//
                    .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.THREAD)//
                    .withFallbackEnabled(true).withFallbackIsolationSemaphoreMaxConcurrentRequests(100)//
                    .withExecutionIsolationThreadInterruptOnFutureCancel(true)//
                    .withExecutionIsolationThreadInterruptOnTimeout(true)//
                    .withExecutionTimeoutEnabled(true).withExecutionTimeoutInMilliseconds(1000);
    return HystrixCommand.Setter.withGroupKey(groupkey).andCommandKey(commandkey)//
                    .andThreadPoolKey(threadpoolkey).andThreadPoolPropertiesDefaults(threadproperties)//
                    .andCommandPropertiesDefaults(commandproperty);
}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
private static Setter setter() {
    HystrixCommandGroupKey groupkey = HystrixCommandGroupKey.Factory.asKey("rpc");
    HystrixCommandKey commandkey = HystrixCommandKey.Factory.asKey("say");
    HystrixThreadPoolKey threadpoolkey = HystrixThreadPoolKey.Factory.asKey("hello-1");
    HystrixThreadPoolProperties.Setter threadproperties = HystrixThreadPoolProperties.Setter()//
                    .withCoreSize(20).withKeepAliveTimeMinutes(5).withMaxQueueSize(1000).withQueueSizeRejectionThreshold(100);

    HystrixCommandProperties.Setter commandproperty = HystrixCommandProperties.Setter()//
                    .withCircuitBreakerEnabled(true).withCircuitBreakerForceClosed(false)//
                    .withCircuitBreakerForceOpen(false).withCircuitBreakerErrorThresholdPercentage(50)//
                    .withCircuitBreakerRequestVolumeThreshold(20)//
                    .withCircuitBreakerSleepWindowInMilliseconds(5000);
    return HystrixCommand.Setter.withGroupKey(groupkey).andCommandKey(commandkey)//
                    .andThreadPoolKey(threadpoolkey).andThreadPoolPropertiesDefaults(threadproperties)//
                    .andCommandPropertiesDefaults(commandproperty);
}
 

import com.netflix.hystrix.HystrixCommand; //导入依赖的package包/类
@Override
public HystrixCommand.Setter create(Target<?> target, Method method) {
  String groupKey = target.name();
  String commandKey = Feign.configKey(target.type(), method);
  return HystrixCommand.Setter
      .withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey))
      .andCommandKey(HystrixCommandKey.Factory.asKey(commandKey));
}