Java CircuitBreakerOptions类代码示例

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
public void example2(Vertx vertx) {
  CircuitBreaker breaker = CircuitBreaker.create("my-circuit-breaker", vertx,
      new CircuitBreakerOptions().setMaxFailures(5).setTimeout(2000)
  );

  breaker.<String>execute(future -> {
    vertx.createHttpClient().getNow(8080, "localhost", "/", response -> {
      if (response.statusCode() != 200) {
        future.fail("HTTP error");
      } else {
        response
            .exceptionHandler(future::fail)
            .bodyHandler(buffer -> {
              future.complete(buffer.toString());
            });
      }
    });
  }).setHandler(ar -> {
    // Do something with the result
  });
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
@Override
public CircuitBreakerOptions visit(final String... key)
        throws ZeroException {
    // 1. Must be the first line, fixed position.
    Ensurer.eqLength(getClass(), 0, (Object[]) key);
    // 2. Read data
    final JsonObject data = this.node.read();
    // 3. CircuitBreakerOptions building.
    final JsonObject config =
            Fn.getSemi(data.containsKey(CIRCUIT) &&
                            null != data.getValue(CIRCUIT), LOGGER,
                    () -> data.getJsonObject(CIRCUIT),
                    JsonObject::new);
    // 4. Verify the configuration data
    return visit(config);
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
@Override
public void start() throws Exception {
    Router router = Router.router(vertx);
    router.get().handler(this::convertPortfolioToEuro);
    router.post().handler(BodyHandler.create());
    router.post().handler(this::delegateWithCircuitBreaker);

    circuit = CircuitBreaker.create("circuit-breaker", vertx,
        new CircuitBreakerOptions()
            .setFallbackOnFailure(true)
            .setMaxFailures(3)
            .setResetTimeout(5000)
            .setTimeout(1000)
    );

    discovery = ServiceDiscovery.create(vertx);


    vertx.createHttpServer()
        .requestHandler(router::accept)
        .listen(8080);
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
public void example1(Vertx vertx) {
  CircuitBreaker breaker = CircuitBreaker.create("my-circuit-breaker", vertx,
      new CircuitBreakerOptions()
          .setMaxFailures(5) // number of failure before opening the circuit
          .setTimeout(2000) // consider a failure if the operation does not succeed in time
          .setFallbackOnFailure(true) // do we call the fallback on failure
          .setResetTimeout(10000) // time spent in open state before attempting to re-try
  );

  breaker.execute(future -> {
    // some code executing with the breaker
    // the code reports failures or success on the given future.
    // if this future is marked as failed, the breaker increased the
    // number of failures
  }).setHandler(ar -> {
    // Get the operation result.
  });
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
public void example3(Vertx vertx) {
  CircuitBreaker breaker = CircuitBreaker.create("my-circuit-breaker", vertx,
      new CircuitBreakerOptions().setMaxFailures(5).setTimeout(2000)
  );

  breaker.executeWithFallback(
      future -> {
        vertx.createHttpClient().getNow(8080, "localhost", "/", response -> {
          if (response.statusCode() != 200) {
            future.fail("HTTP error");
          } else {
            response
                .exceptionHandler(future::fail)
                .bodyHandler(buffer -> {
                  future.complete(buffer.toString());
                });
          }
        });
      }, v -> {
        // Executed when the circuit is opened
        return "Hello";
      })
      .setHandler(ar -> {
        // Do something with the result
      });
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
public void example4(Vertx vertx) {
  CircuitBreaker breaker = CircuitBreaker.create("my-circuit-breaker", vertx,
      new CircuitBreakerOptions().setMaxFailures(5).setTimeout(2000)
  ).fallback(v -> {
    // Executed when the circuit is opened.
    return "hello";
  });

  breaker.execute(
      future -> {
        vertx.createHttpClient().getNow(8080, "localhost", "/", response -> {
          if (response.statusCode() != 200) {
            future.fail("HTTP error");
          } else {
            response
                .exceptionHandler(future::fail)
                .bodyHandler(buffer -> {
                  future.complete(buffer.toString());
                });
          }
        });
      });
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
public void example5(Vertx vertx) {
  CircuitBreaker breaker = CircuitBreaker.create("my-circuit-breaker", vertx,
      new CircuitBreakerOptions().setMaxFailures(5).setTimeout(2000)
  ).openHandler(v -> {
    System.out.println("Circuit opened");
  }).closeHandler(v -> {
    System.out.println("Circuit closed");
  });

  breaker.execute(
      future -> {
        vertx.createHttpClient().getNow(8080, "localhost", "/", response -> {
          if (response.statusCode() != 200) {
            future.fail("HTTP error");
          } else {
            // Do something with the response
            future.complete();
          }
        });
      });
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
public CircuitBreakerImpl(String name, Vertx vertx, CircuitBreakerOptions options) {
  Objects.requireNonNull(name);
  Objects.requireNonNull(vertx);
  this.vertx = vertx;
  this.name = name;

  if (options == null) {
    this.options = new CircuitBreakerOptions();
  } else {
    this.options = new CircuitBreakerOptions(options);
  }

  this.metrics = new CircuitBreakerMetrics(vertx, this, options);

  sendUpdateOnEventBus();

  if (this.options.getNotificationPeriod() > 0) {
    this.periodicUpdateTask = vertx.setPeriodic(this.options.getNotificationPeriod(), l -> sendUpdateOnEventBus());
  } else {
    this.periodicUpdateTask = -1;
  }
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
public static void main(String[] args) {
  Vertx vertx = Vertx.vertx();
  CircuitBreakerOptions options = new CircuitBreakerOptions()
    .setFallbackOnFailure(true)
    .setMaxFailures(10)
    .setResetTimeout(5000)
    .setTimeout(1000)
    .setMetricsRollingWindow(10000);

  CircuitBreaker cba = CircuitBreaker.create("A", vertx, options);
  CircuitBreaker cbb = CircuitBreaker.create("B", vertx, options);
  CircuitBreaker cbc = CircuitBreaker.create("C", vertx, options);

  Router router = Router.router(vertx);
  router.get("/metrics").handler(HystrixMetricHandler.create(vertx));


  router.get("/A").handler(rc -> a(rc, cba));
  router.get("/B").handler(rc -> b(rc, cbb));
  router.get("/C").handler(rc -> c(rc, cbc));

  vertx.createHttpServer()
    .requestHandler(router::accept)
    .listen(8080);
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
@Test
@Repeat(5)
public void testOk() {
  breaker = CircuitBreaker.create("test", vertx, new CircuitBreakerOptions());
  assertThat(breaker.state()).isEqualTo(CircuitBreakerState.CLOSED);

  AtomicBoolean operationCalled = new AtomicBoolean();
  AtomicReference<String> completionCalled = new AtomicReference<>();
  breaker.<String>execute(fut -> {
    operationCalled.set(true);
    fut.complete("hello");
  }).setHandler(ar -> completionCalled.set(ar.result()));

  await().until(operationCalled::get);
  await().until(() -> completionCalled.get().equalsIgnoreCase("hello"));
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
@Test
@Repeat(5)
public void testWithUserFutureOk() {
  breaker = CircuitBreaker.create("test", vertx, new CircuitBreakerOptions());
  assertThat(breaker.state()).isEqualTo(CircuitBreakerState.CLOSED);

  AtomicBoolean operationCalled = new AtomicBoolean();
  AtomicReference<String> completionCalled = new AtomicReference<>();

  Future<String> userFuture = Future.future();
  userFuture.setHandler(ar ->
    completionCalled.set(ar.result()));

  breaker.executeAndReport(userFuture, fut -> {
    operationCalled.set(true);
    fut.complete("hello");
  });

  await().until(operationCalled::get);
  await().until(() ->  completionCalled.get().equalsIgnoreCase("hello"));
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
@Test
public void testAsynchronousOk() {
  breaker = CircuitBreaker.create("test", vertx, new CircuitBreakerOptions());
  assertThat(breaker.state()).isEqualTo(CircuitBreakerState.CLOSED);

  AtomicBoolean called = new AtomicBoolean();
  AtomicReference<String> result = new AtomicReference<>();
  breaker.<String>execute(future ->
    vertx.setTimer(100, l -> {
      called.set(true);
      future.complete("hello");
    })
  ).setHandler(ar -> result.set(ar.result()));

  await().until(called::get);
  await().untilAtomic(result, is("hello"));
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
@Test
public void testAsynchronousWithUserFutureOk() {
  breaker = CircuitBreaker.create("test", vertx, new CircuitBreakerOptions());
  assertThat(breaker.state()).isEqualTo(CircuitBreakerState.CLOSED);

  AtomicBoolean called = new AtomicBoolean();
  AtomicReference<String> result = new AtomicReference<>();

  Future<String> userFuture = Future.future();
  userFuture.setHandler(ar -> result.set(ar.result()));

  breaker.executeAndReport(userFuture, future ->
    vertx.setTimer(100, l -> {
      called.set(true);
      future.complete("hello");
    })
  );

  await().until(called::get);
  await().untilAtomic(result, is("hello"));
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
@Before
public void setUp() {
  vertx = Vertx.vertx();
  items.clear();
  cb = CircuitBreaker.create("circuit-breaker", vertx, new CircuitBreakerOptions()
      .setFallbackOnFailure(true)
      .setTimeout(500)
      .setResetTimeout(1000));

  vertx.eventBus().consumer("ok", message -> message.reply("OK"));

  vertx.eventBus().consumer("fail", message -> message.fail(100, "Bad bad bad"));

  vertx.eventBus().consumer("exception", message -> {
    throw new RuntimeException("RT - Bad bad bad");
  });

  vertx.eventBus().consumer("timeout", message -> vertx.setTimer(2000, x -> message.reply("Too late")));
}
 

import io.vertx.circuitbreaker.CircuitBreakerOptions; //导入依赖的package包/类
@Test
public void testEviction(TestContext tc) {
  breaker = CircuitBreaker.create("some-circuit-breaker", vertx,
    new CircuitBreakerOptions().setMetricsRollingWindow(10));
  Async async = tc.async();


  int count = 1000;

  List<Future> list = new ArrayList<>();
  for (int i = 0; i < count; i++) {
    list.add(breaker.execute(commandThatWorks()));
  }

  CompositeFuture.all(list)
    .setHandler(ar -> {
      assertThat(ar).succeeded();
      assertThat(metrics().getInteger("totalOperationCount")).isEqualTo(1000);
      assertThat(metrics().getInteger("rollingOperationCount")).isLessThan(1000);
      async.complete();
    });
}