Java SockJSHandler.bridge方法代码示例

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
@Override
public SFDCRouterExtension addRoutes(final Router router) {
	// Socket handler
	final SockJSHandlerOptions options = new SockJSHandlerOptions().setHeartbeatInterval(2000);
	final SockJSHandler sockJSHandler = SockJSHandler.create(this.vertx, options);

	final BridgeOptions bo = new BridgeOptions()
			.addOutboundPermitted(new PermittedOptions().setAddress(this.getWebSocketName()));

	sockJSHandler.bridge(bo, event -> {
		this.logger.info("A websocket event occurred: " + event.type() + "; " + event.getRawMessage());
		event.complete(true);
	});

	final String someURL = this.getConsumerConfig().getUrl();
	this.logger.info("Router listening on " + someURL + " for " + this.getWebSocketName());
	router.route(someURL).handler(sockJSHandler);
	return this;
}
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
private void initWebSocket() {
    Router router = Router.router(vertx);
    SockJSHandlerOptions options = new SockJSHandlerOptions()
            .setHeartbeatInterval(1000 * 60);
    SockJSHandler sockJSHandler = SockJSHandler.create(vertx, options);

    PermittedOptions inboundPermitted = new PermittedOptions().setAddressRegex("server/.*");
    PermittedOptions outboundPermitted = new PermittedOptions().setAddressRegex("client/.*");

    BridgeOptions ops = new BridgeOptions()
            .addInboundPermitted(inboundPermitted)
            .addOutboundPermitted(outboundPermitted);

    sockJSHandler.bridge(ops);

    router.route("/eb/*").handler(sockJSHandler);
    mainRouter.mountSubRouter("/ws", router);
}
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
private void createSockJSServer(final ConfigurationContext context)  throws InitializationException {

        final int port = context.getProperty(PORT).asInteger();
        final String ContextPath = context.getProperty(CONTEXT_PATH).getValue();

        Router router = Router.router(vertx);

        SockJSHandler sockJSHandler = SockJSHandler.create(vertx);

        BridgeOptions options = new BridgeOptions();
        if (context.getProperty(INBOUND_ADDRESS_REGEX).isSet()) {
            options.addInboundPermitted(new PermittedOptions().setAddressRegex(context.getProperty(INBOUND_ADDRESS_REGEX).getValue()));
        }
        if (context.getProperty(OUTBOUND_ADDRESS_REGEX).isSet()) {
            options.addOutboundPermitted(new PermittedOptions().setAddressRegex(context.getProperty(OUTBOUND_ADDRESS_REGEX).getValue()));
        }

        sockJSHandler.bridge(options);

        router.route(ContextPath).handler(sockJSHandler);
        httpServer = vertx.createHttpServer().requestHandler(router::accept).listen(port);
    }
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
public void example48_1(Vertx vertx) {

    Router router = Router.router(vertx);

    // Let through any messages sent to 'demo.orderService' from the client
    PermittedOptions inboundPermitted = new PermittedOptions().setAddress("demo.orderService");

    SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
    BridgeOptions options = new BridgeOptions().addInboundPermitted(inboundPermitted);

    sockJSHandler.bridge(options, be -> {
      if (be.type() == BridgeEventType.PUBLISH || be.type() == BridgeEventType.SEND) {
        // Add some headers
        JsonObject headers = new JsonObject().put("header1", "val").put("header2", "val2");
        JsonObject rawMessage = be.getRawMessage();
        rawMessage.put("headers", headers);
        be.setRawMessage(rawMessage);
      }
      be.complete(true);
    });

    router.route("/eventbus/*").handler(sockJSHandler);


  }
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
public void example49(Vertx vertx) {

    Router router = Router.router(vertx);

    // Let through any messages sent to 'demo.orderMgr' from the client
    PermittedOptions inboundPermitted = new PermittedOptions().setAddress("demo.someService");

    SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
    BridgeOptions options = new BridgeOptions().addInboundPermitted(inboundPermitted);

    sockJSHandler.bridge(options, be -> {
      if (be.type() == BridgeEventType.PUBLISH || be.type() == BridgeEventType.RECEIVE) {
        if (be.getRawMessage().getString("body").equals("armadillos")) {
          // Reject it
          be.complete(false);
          return;
        }
      }
      be.complete(true);
    });

    router.route("/eventbus/*").handler(sockJSHandler);


  }
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
public void handleSocketIdle(Vertx vertx, PermittedOptions inboundPermitted) {
  Router router = Router.router(vertx);

  // Initialize SockJS handler
  SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
  BridgeOptions options = new BridgeOptions().addInboundPermitted(inboundPermitted).setPingTimeout(5000);

  sockJSHandler.bridge(options, be -> {
    if (be.type() == BridgeEventType.SOCKET_IDLE) {
      // Do some custom handling...
    }

    be.complete(true);
  });

  router.route("/eventbus/*").handler(sockJSHandler);
}
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
private SockJSHandler eventBusHandler() {
  SockJSHandler handler = SockJSHandler.create(vertx);
  BridgeOptions options = new BridgeOptions();
  // open access
  PermittedOptions permitted = new PermittedOptions();
  options.addOutboundPermitted(permitted);
  handler.bridge(options);
  return handler;
}
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
private SockJSHandler configureSockJsHandler(VertxContext vertxContext, BridgeOptions bridgeOptions,
                                             JsonObject config) {
    SockJSHandler sockJSHandler = SockJSHandler.create(vertxContext.vertx());
    sockJSHandler.bridge(bridgeOptions, event -> event.complete(true));
    JsonArray jsonArray=config.getJsonArray(ALLOWED_ORIGINS, new JsonArray().add("*"));

    sockJSHandler.socketHandler(event -> jsonArray.forEach(o -> event.headers().set(ACCESS_CONTROL_ALLOW_ORIGIN, (String)o)));
    return sockJSHandler;
}
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
@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;
}
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
@Override
public void start() throws Exception {
  super.start();
  Router router = Router.router(vertx);

  // create Dropwizard metrics service
  MetricsService service = MetricsService.create(vertx);

  // event bus bridge
  SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
  BridgeOptions options = new BridgeOptions()
    .addOutboundPermitted(new PermittedOptions().setAddress("microservice.monitor.metrics"))
    .addOutboundPermitted(new PermittedOptions().setAddress("events.log"));

  sockJSHandler.bridge(options);
  router.route("/eventbus/*").handler(sockJSHandler);

  // discovery endpoint
  ServiceDiscoveryRestEndpoint.create(router, discovery);

  // static content
  router.route("/*").handler(StaticHandler.create());

  int port = config().getInteger("monitor.http.port", 9100);
  String host = config().getString("monitor.http.host", "0.0.0.0");
  int metricsInterval = config().getInteger("monitor.metrics.interval", 5000);

  vertx.createHttpServer()
    .requestHandler(router::accept)
    .listen(port, host);

  // send metrics message to the event bus
  vertx.setPeriodic(metricsInterval, t -> {
    JsonObject metrics = service.getMetricsSnapshot(vertx);
    vertx.eventBus().publish("microservice.monitor.metrics", metrics);
  });
}
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
private void addEventBusHandler() {
	SockJSHandler handler = null;
	if (localRouter != null) {
		SockJSHandlerOptions sockJSoptions = new SockJSHandlerOptions().setHeartbeatInterval(2000);
		handler = SockJSHandler.create(Mesh.vertx(), sockJSoptions);
		BridgeOptions bridgeOptions = new BridgeOptions();
		for (String addr : Events.publicEvents()) {
			bridgeOptions.addInboundPermitted(new PermittedOptions().setAddress(addr));
			bridgeOptions.addOutboundPermitted(new PermittedOptions().setAddress(addr));
		}
		handler.bridge(bridgeOptions, event -> {
			if (log.isDebugEnabled()) {
				if (event.type() == BridgeEventType.SOCKET_CREATED) {
					log.debug("A websocket was created");
				}
			}
			// Only grant access to authenticated users
			User user = event.socket().webUser();
			boolean isAuthenticated = user != null;
			event.complete(isAuthenticated);
		});
	}

	secureAll();
	EndpointRoute endpoint = createEndpoint();
	endpoint.setRAMLPath("/");
	endpoint.description("This endpoint provides a sockjs complient websocket which can be used to interface with the vert.x eventbus.");
	endpoint.path("/*").handler(handler);

}
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
private SockJSHandler socketJSRegister() {
	SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
	BridgeOptions options = new BridgeOptions();
	//[appName].[address]
	options.addOutboundPermitted(new PermittedOptions().setAddressRegex(appConfig.getAppName() + "..*"));
	sockJSHandler.bridge(options, event -> {
		if (event.type() == BridgeEventType.SOCKET_CREATED) {
		}
		event.complete(true);
	});
	return sockJSHandler;

}
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
private SockJSHandler eventBusHandler() {
	SockJSHandler handler = SockJSHandler.create(vertx);
	BridgeOptions options = new BridgeOptions();
	PermittedOptions permitted = new PermittedOptions(); /* allow everything, we don't care for the demo */
	options.addOutboundPermitted(permitted);
	handler.bridge(options);
	return handler;
}
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
public void createServer() throws InterruptedException {
    vertx = Vertx.vertx();
    CountDownLatch latch = new CountDownLatch(1);
    Router router = Router.router(vertx);

    // events specific to THOPs are made available over the bridge
    SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
    BridgeOptions options = new BridgeOptions();
    options.addOutboundPermitted(new PermittedOptions().setAddress("test")).
            addInboundPermitted(new PermittedOptions().setAddress("test")).
            addOutboundPermitted(new PermittedOptions().setAddress("end")).
            addInboundPermitted(new PermittedOptions().setAddress("end")).
            addInboundPermitted(new PermittedOptions().setAddress("reply")).
            addOutboundPermitted(new PermittedOptions().setAddress("replyTest"));

    sockJSHandler.bridge(options);

    router.route("/bridge/*").handler(sockJSHandler);
    // for reply test
    vertx.eventBus().consumer("reply", msg -> {
        vertx.eventBus().send("replyTest", "replyToMe", reply -> {
            assertEquals("bubu", reply.result().body().toString());
            reply.result().reply("ok", replyOfreply -> {
                assertEquals("roger", replyOfreply.result().body().toString());
            });
            msg.reply("ok");
            vertx.eventBus().send("test", "ok");
        });
    });
    vertx.createHttpServer().requestHandler(router::accept).listen(8765, (res) -> {
        latch.countDown();
    });

    latch.await();
    System.out.println("Server listening on port 8765");
}
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入方法依赖的package包/类
@BeforeClass
public static void createServer() throws InterruptedException {
    vertx = Vertx.vertx();
    CountDownLatch latch = new CountDownLatch(1);
    Router router = Router.router(vertx);

    // events specific to THOPs are made available over the bridge
    SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
    BridgeOptions options = new BridgeOptions();
    options.addOutboundPermitted(new PermittedOptions().setAddress("test")).
            addInboundPermitted(new PermittedOptions().setAddress("test")).
            addOutboundPermitted(new PermittedOptions().setAddress("end")).
            addInboundPermitted(new PermittedOptions().setAddress("end")).
            addInboundPermitted(new PermittedOptions().setAddress("reply")).
            addOutboundPermitted(new PermittedOptions().setAddress("replyTest"));

    sockJSHandler.bridge(options);

    router.route("/bridge/*").handler(sockJSHandler);
    // for reply test
    vertx.eventBus().consumer("reply", msg -> {
        vertx.eventBus().send("replyTest", "replyToMe", reply -> {
            assertEquals("bubu", reply.result().body().toString());
            reply.result().reply("ok", replyOfreply -> {
                assertEquals("roger", replyOfreply.result().body().toString());
            });
            msg.reply("ok");
            vertx.eventBus().send("test", "ok");
        });
    });
    vertx.createHttpServer().requestHandler(router::accept).listen(8765, (res) -> {
        latch.countDown();
    });

    latch.await();
    System.out.println("Server listening on port 8765");
}