Java SockJSHandler类代码示例

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入依赖的package包/类
private SockJSHandler eventBusHandler() {
 	SockJSHandlerOptions options = new SockJSHandlerOptions().setHeartbeatInterval(2000);
    BridgeOptions boptions = new BridgeOptions()
            .addOutboundPermitted(new PermittedOptions().setAddressRegex(MessageDefinitions.UPDATE_ORDERBOOK+":[A-Z]+-[A-Z]+"))
            .addOutboundPermitted(new PermittedOptions().setAddressRegex(MessageDefinitions.UPDATE_INDICATORS+":[A-Z]+-[A-Z]+"))
            .addOutboundPermitted(new PermittedOptions().setAddressRegex(MessageDefinitions.ORDERBOOK_READY+":[A-Z]+-[A-Z]+"))
    		.addInboundPermitted(new PermittedOptions().setAddressRegex(MessageDefinitions.GET_ORDERBOOK+":[A-Z]+-[A-Z]+"))
    		.addInboundPermitted(new PermittedOptions().setAddressRegex("getMovingAverage:[A-Z]+-[A-Z]+"))
    		.addInboundPermitted(new PermittedOptions().setAddressRegex(MessageDefinitions.REDEPLOYBITTREXVERTICLES));
    return SockJSHandler.create(vertx, options).bridge(boptions, event -> {
         if (event.type() == BridgeEventType.SOCKET_CREATED) {
            System.out.println("A socket was created!");
         } else if (event.type() == BridgeEventType.SOCKET_CLOSED){
        	 System.out.println("A socket was closed!");
         } else if (event.type() == BridgeEventType.UNREGISTER || event.type() == BridgeEventType.REGISTER){
        	 System.out.println(event.getRawMessage().encode());
         }
        event.complete(true);
    });
}
 

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包/类
@Override
public SockJSHandler configure(VertxContext vertxContext, ServerConfiguration<JsonObject, JsonObject[]> config) {

    JsonObject sockJsConfig=config.getJsonObject(CONFIG_KEY, makeDefaultConfig());

    BridgeOptions bridgeOptions = configureBridgeOptions(sockJsConfig);

    SockJSHandler sockJSHandler = configureSockJsHandler(vertxContext, bridgeOptions, sockJsConfig);
    boolean CSRFProteceted=sockJsConfig.getBoolean(CSRF_PROTECTED, false);
    if(CSRFProteceted) {
        if(config.getString(CSRF_SECRET, EMPTY_CSRF_SECRET).isEmpty() || config.getString(CSRF_SECRET,
                EMPTY_CSRF_SECRET).length()<12)
            throw new CsrfProtectionEnabledBuInvalidSecretProvided();
        vertxContext.router().route().path(VertxBusContext.DEFAULT_EVENTBUS_PATH).handler(CookieHandler.create());
        vertxContext.router().route().path(VertxBusContext.DEFAULT_EVENTBUS_PATH).handler(
                CSRFHandler.create(config.getString(CSRF_SECRET, EMPTY_CSRF_SECRET)));
    }
    return sockJSHandler;
}
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入依赖的package包/类
private void configureWithConfigurator(VertxContext vertxContext,
                                       ServerConfiguration<JsonObject, JsonObject[]> serverConfiguration) {
    ServiceLoader<EventBusSockJsConfigurator> configurators=ServiceLoader.load(EventBusSockJsConfigurator.class);
    String targetConfigurator=serverConfiguration.getString(SOCKJS_CONFIGURATOR_CONFIG_KEY);
    Iterator<EventBusSockJsConfigurator> configuratorIterator=configurators.iterator();
    while(configuratorIterator.hasNext()){
        EventBusSockJsConfigurator configurator=configuratorIterator.next();
        if(configurator.getClass().getName().equals(targetConfigurator)){
            SockJSHandler sockJSHandler=configurator.configure(vertxContext, serverConfiguration);
            vertxContext.router().route().path(VertxBusContext.DEFAULT_EVENTBUS_PATH).handler(sockJSHandler);
            return;
        }
    }

    throw new SockJsConfiguratorNotFoundInClassPathException(targetConfigurator);
}
 

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包/类
@Override
public void start() {
	// Chat with SockJS
	Router router = Router.router(vertx);
	List<String> ids = new ArrayList<>();
	router.route("/chatSockjs/*").handler(SockJSHandler.create(vertx).socketHandler(socket -> {
		final String id = socket.writeHandlerID();
		ids.add(id); // entering
		socket.endHandler(data -> {
			ids.remove(id); // leaving
		});
		socket.handler(buffer -> { // receiving

			// extra: pojo example
			if (Pojofy.socket(socket, Client.urlPojo, buffer, Dto.class, this::serviceDoSomething)) {
				return;
			}

			ids.forEach(i -> vertx.eventBus().send(i, buffer)); // broadcasting
			// to reply to one: socket.write()

		});
	}));

	AllExamplesServer.start(Client.class, 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 visit() {
  sockJSHandler = SockJSHandler.create(config.getVertx(), config.getSockJSOptions());
  try {
    instance = clazz.newInstance();
    injectServices();
  } catch (Exception e) {
    throw new VertxException("Could not instanciate socket controller : " + clazz.getName(), e);
  }
  createHandlers();
  sockJSHandler.socketHandler(ws -> {
    openHandlers.forEach(handler -> tryToInvoke(instance, handler, ws, null));
    ws.handler(buff -> messageHandlers.forEach(messageHandler -> tryToInvoke(instance, messageHandler, ws, buff)));
    ws.endHandler(voidz -> closeHandlers.forEach(closeHandler -> tryToInvoke(instance, closeHandler, ws, null)));
  });
  normalizePath();
  router.route(path).handler(sockJSHandler);
}
 

import io.vertx.ext.web.handler.sockjs.SockJSHandler; //导入依赖的package包/类
public void serviceAndSockJS(Vertx vertx) {
  SomeDatabaseService service = new SomeDatabaseServiceImpl();
  ProxyHelper.registerService(SomeDatabaseService.class, vertx, service,
      "database-service-address");


  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("database-service-address"))
      .addOutboundPermitted(new PermittedOptions()
          .setAddress("database-service-address"));

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

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

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;
}