How to use

setAddress

method

in

io.vertx.ext.web.handler.sockjs.PermittedOptions

 @Override
 public void start() throws Exception {

  Router router = Router.router(vertx);

  // Allow events for the designated addresses in/out of the event bus bridge
  BridgeOptions opts = new BridgeOptions()
    .addOutboundPermitted(new PermittedOptions().setAddress("feed"));

  // Create the event bus bridge and add it to the router.
  SockJSHandler ebHandler = SockJSHandler.create(vertx).bridge(opts);
  router.route("/eventbus/*").handler(ebHandler);

  // Start the web server and tell it to use the router to handle requests.
  vertx.createHttpServer().requestHandler(router).listen(8080);

  EventBus eb = vertx.eventBus();

  vertx.setPeriodic(1000l, t -> {
   // Create a timestamp string
   String timestamp = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM).format(Date.from(Instant.now()));

   eb.send("feed", new JsonObject().put("now", timestamp));
  });
 }
}

@Singleton
@Nullable
@Provides
public BridgeOptions provideBridgeOptions(VertxFactory vertxFactory) {
  BridgeOptions opts = null;
  if (vertxFactory.isRouterDefined() && vertxFactory.router().isSockJSHandlerDefined()) {
    PermissionsConfig permissionsConfig = vertxFactory.router().sockjs().bridge().permissions();
    opts = new BridgeOptions();
    for (String inboundPermmited : permissionsConfig.inbound()) {
      opts.addInboundPermitted(new PermittedOptions().setAddress(inboundPermmited));
    }
    for (String inboundPermmited : permissionsConfig.inboundRegex()) {
      opts.addInboundPermitted(new PermittedOptions().setAddressRegex(inboundPermmited));
    }
    for (String outboundPermmited : permissionsConfig.outbound()) {
      opts.addOutboundPermitted(new PermittedOptions().setAddress(outboundPermmited));
    }
    for (String outboundPermmited : permissionsConfig.outboundRegex()) {
      opts.addOutboundPermitted(new PermittedOptions().setAddressRegex(outboundPermmited));
    }
  }
  return opts;
}

 @Override
 public void start() throws Exception {

  Router router = Router.router(vertx);

  // Allow events for the designated addresses in/out of the event bus bridge
  BridgeOptions opts = new BridgeOptions()
    .addOutboundPermitted(new PermittedOptions().setAddress("feed"));

  // Create the event bus bridge and add it to the router.
  SockJSHandler ebHandler = SockJSHandler.create(vertx).bridge(opts);
  router.route("/eventbus/*").handler(ebHandler);

  // Create a router endpoint for the static content.
  router.route().handler(StaticHandler.create());

  // Start the web server and tell it to use the router to handle requests.
  vertx.createHttpServer().requestHandler(router).listen(8080);

  EventBus eb = vertx.eventBus();

  vertx.setPeriodic(1000l, t -> {
   // Create a timestamp string
   String timestamp = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM).format(Date.from(Instant.now()));

   eb.send("feed", new JsonObject().put("now", timestamp));
  });
 }
}

 @Override
 public void start() throws Exception {

  Router router = Router.router(vertx);

  // Allow events for the designated addresses in/out of the event bus bridge
  BridgeOptions opts = new BridgeOptions()
   .addOutboundPermitted(new PermittedOptions().setAddress("feed"));

  // Create the event bus bridge and add it to the router.
  SockJSHandler ebHandler = SockJSHandler.create(vertx).bridge(opts);
  router.route("/eventbus/*").handler(ebHandler);

  // Create a router endpoint for the static content.
  router.route().handler(StaticHandler.create());

  // Start the web server and tell it to use the router to handle requests.
  vertx.createHttpServer().requestHandler(router).listen(8080);

  EventBus eb = vertx.eventBus();

  vertx.setPeriodic(1000l, t -> {
   // Create a timestamp string
   String timestamp = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM).format(Date.from(Instant.now()));

   eb.send("feed", new JsonObject().put("now", timestamp));
  });
 }
}

 @Override
 public void start() throws Exception {

  Router router = Router.router(vertx);

  // Allow events for the designated addresses in/out of the event bus bridge
  BridgeOptions opts = new BridgeOptions()
    .addInboundPermitted(new PermittedOptions().setAddress("com.example:cmd:poke-server"))
    .addOutboundPermitted(new PermittedOptions().setAddress("com.example:stat:server-info"));

  // Create the event bus bridge and add it to the router.
  SockJSHandler ebHandler = SockJSHandler.create(vertx).bridge(opts);
  router.route("/eventbus/*").handler(ebHandler);

  // Create a router endpoint for the static content.
  router.route().handler(StaticHandler.create());

  // Start the web server and tell it to use the router to handle requests.
  vertx.createHttpServer().requestHandler(router).listen(8080);

  EventBus eb = vertx.eventBus();

  vertx.setPeriodic(1000l, t -> {
   // Create a timestamp string
   String timestamp = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM).format(Date.from(Instant.now()));
   eb.send("com.example:stat:server-info", new JsonObject().put("systemTime", timestamp));
  });
 }
}

 @Override
 public void start() throws Exception {

  Router router = Router.router(vertx);

  // Allow events for the designated addresses in/out of the event bus bridge
  BridgeOptions opts = new BridgeOptions()
      .addInboundPermitted(new PermittedOptions().setAddress("chat.message"))
      .addOutboundPermitted(new PermittedOptions().setAddress("chat.message"));

  // Create the event bus bridge and add it to the router.
  SockJSHandler ebHandler = SockJSHandler.create(vertx).bridge(opts);
  router.route("/eventbus/*").handler(ebHandler);

  // Create a router endpoint for the static content.
  router.route().handler(StaticHandler.create());

  // Start the web server and tell it to use the router to handle requests.
  vertx.createHttpServer().requestHandler(router).listen(8080);
 }
}

.addInboundPermitted(new PermittedOptions().setAddress("chat.to.server"))
.addOutboundPermitted(new PermittedOptions().setAddress("chat.to.client"));

options.setOutboundPermitted(Collections.singletonList(new PermittedOptions().setAddress("dashboard")));
router.route("/eventbus/*").handler(SockJSHandler.create(vertx).bridge(options));

BridgeOptions options = new BridgeOptions().addOutboundPermitted(new PermittedOptions().setAddress("news-feed"));

addOutboundPermitted(
  new PermittedOptions().
    setAddress("metrics")
);

.setAddress("vtoons.listAlbums"))
.setAddress("vtoons.login"))
.setAddress("vtoons.placeOrder")
.setRequiredAuthority("place_order"))

@Override
public void start() throws Exception {
  /* test service */
  final TestService testService = new TestService();
  /* address */
  final String address = "testservice";
  /* service builder */
  final ServiceBuilder serviceBuilder = ServiceBuilder.serviceBuilder();
  serviceBuilder.setServiceObject(testService);
  final ServiceQueue serviceQueue = serviceBuilder.build();
  /* vertx event bus bridge to qbit. */
  final VertxEventBusBridgeBuilder vertxEventBusBridgeBuilder = VertxEventBusBridgeBuilder
      .vertxEventBusBridgeBuilder()
      .setVertx(vertx);
  vertxEventBusBridgeBuilder.addBridgeAddress(address, TestService.class);
  final Router router = Router.router(vertx);
  router.route("/health/").handler(routingContext -> routingContext.response().end("\"ok\""));
    /* Configure bridge at this HTTP/WebSocket URI. */
  router.route("/eventbus/*").handler(SockJSHandler.create(vertx).bridge(
      new BridgeOptions()
          .addInboundPermitted(new PermittedOptions().setAddress(address))
          .addOutboundPermitted(new PermittedOptions().setAddress(address))
  ));
  vertxEventBusBridgeBuilder.setServiceQueue(serviceQueue);
  serviceQueue.startAll(); //startall not supported yet for bridge.
  vertxEventBusBridgeBuilder.build();
  vertx.createHttpServer().requestHandler(router::accept).listen(8080);
  System.out.println("Bound to 8080");
}

private void addInboundPermitted(BridgeOptions bridgeOptions, JsonObject inbound) {
  PermittedOptions permittedOptions=new PermittedOptions();
  permittedOptions.setAddress(inbound.getString(ADDRESS));
  String authority=inbound.getString(REQUIRED_AUTHORITY, EMPTY_CSRF_SECRET);
  if(!authority.isEmpty())
    permittedOptions.setRequiredAuthority(authority);
  bridgeOptions.addInboundPermitted(permittedOptions);
}

private void addOutboundPermitted(BridgeOptions bridgeOptions, JsonObject outbound) {
  PermittedOptions permittedOptions=new PermittedOptions();
  permittedOptions.setAddress(outbound.getString(ADDRESS));
  String authority=outbound.getString(REQUIRED_AUTHORITY, EMPTY_CSRF_SECRET);
  if(!authority.isEmpty())
    permittedOptions.setRequiredAuthority(authority);
  bridgeOptions.addOutboundPermitted(permittedOptions);
}

final BridgeOptions options = new BridgeOptions()
    .addInboundPermitted(
        new PermittedOptions().setAddress(Services.HELLO_WORLD.toString()))
    .addInboundPermitted(new PermittedOptions().setAddress(HELLO_WORLD_SERVICE))
    .addOutboundPermitted(new PermittedOptions().setAddress(HELLO_WORLD_SERVICE));

  @Override
  public Completable preRoute() {
    return Completable.defer(() -> {
      AppGlobals globals = AppGlobals.get();
      SockJSHandler sockJSHandler = SockJSHandler.create(globals.getVertx());
      BridgeOptions bridgeOptions = new BridgeOptions()
          .addInboundPermitted(new PermittedOptions().setAddress("app.markdown"))
          .addOutboundPermitted(new PermittedOptions().setAddress("page.saved"));
      sockJSHandler.bridge(bridgeOptions);
      globals.getRouter().route("/eventbus/*").handler(sockJSHandler);
      return super.preRoute();
    });
  }
});

  @Override
  public Completable preRoute() {
    return Completable.defer(() -> {
      AppGlobals globals = AppGlobals.get();
      SockJSHandler sockJSHandler = SockJSHandler.create(globals.getVertx());
      BridgeOptions bridgeOptions = new BridgeOptions()
          .addInboundPermitted(new PermittedOptions().setAddress("app.markdown"))
          .addOutboundPermitted(new PermittedOptions().setAddress("page.saved"));
      sockJSHandler.bridge(bridgeOptions);
      globals.getRouter().route("/eventbus/*").handler(sockJSHandler);
      return super.preRoute();
    });
  }
});

BridgeOptions options = new BridgeOptions();
options
  .addOutboundPermitted(new PermittedOptions().setAddress("market"))
  .addOutboundPermitted(new PermittedOptions().setAddress("portfolio"))
  .addOutboundPermitted(new PermittedOptions().setAddress("service.portfolio"))
  .addInboundPermitted(new PermittedOptions().setAddress("service.portfolio"))
  .addOutboundPermitted(new PermittedOptions().setAddress("vertx.circuit-breaker"));

  @Override
  public SockJSHandler configure(VertxContext vertxContext, ServerConfiguration<JsonObject, JsonObject[]> config) {
    BridgeOptions bridgeOptions=new BridgeOptions();
    bridgeOptions.addOutboundPermitted(new PermittedOptions().setAddress(VertxBusContext.DEFAULT_SOCKJS_ADDRESS));

    SockJSHandler sockJSHandler = SockJSHandler.create(vertxContext.vertx());
    sockJSHandler.bridge(bridgeOptions, event -> event.complete(true));

    sockJSHandler.socketHandler(event -> event.headers().set(ACCESS_CONTROL_ALLOW_ORIGIN, ALLOW_ALL));
    return sockJSHandler;
  }
}

.addOutboundPermitted(new PermittedOptions().setAddress("microservice.monitor.metrics"))
.addOutboundPermitted(new PermittedOptions().setAddress("events.log"));