【Vertx】利用vertx实现websocket数据推送

前言

vertx是一个基于JVM、轻量级、高性能的应用平台，非常适用于最新的移动端后台、互联网、企业应用架构。
Vert.x基于全异步Java服务器Netty，并扩展出了很多有用的特性。Vert.x的亮点有：
【同时支持多种编程语言】目前已经支持了Java/JavaScript/Ruby/Python/Groovy/Clojure/Ceylon等。对程序员来说，直接好处是可以使用各种语言丰富的lib，同时也不再为编程语言选型而纠结。
【异步无锁编程】经典的多线程编程模型能满足很多web开发场景，但随着移动互联网并发连接数的猛增，多线程并发控制模型性能难以扩展、同时要想控制好并发锁需要较高的技巧，目前Reactor异步编程模型开始跑马圈地，而Vert.x就是这种异步无锁编程的一个首选。
【对各种io的丰富支持】目前Vert.x的异步模型已支持TCP, UDP, File System, DNS, Event Bus,
Sockjs等 【极好的分布式开发支持】Vert.x通过Event Bus事件总线，可以轻松编写分布式解耦的程序，具有很好的扩展性。
【生态体系日趋成熟】Vert.x归入Eclipse基金会门下，异步驱动已经支持了Postgres/MySQL/MongoDB/Redis等常用组件。并且有若干Vert.x在生产环境中的应用案例。

verxt分为几个不同的部分（具体可以参看官方文档 vertx官方文档）：

core
web
web client
data access(MongoDB client、JDBC client、SQL common、Redis client、MySQL / PostgreSQL client)
Integration
Event Bus Bridge
Authentication and Authorisation
Reactive
Microservices
MQTT Server
Devops
Testing
Clustering
Services
Cloud
Advanced

本文的知识点主要用到了core和web部分。
下面介绍一下怎么利用vertx实现websocket的数据推送

后端部分：

1，创建一个maven工程
如果不知道怎么创建maven工程，请参照笔者之前的博客：

maven入门

其中pom.xml文件的内容如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <groupId>ShareBikegroupId>
    <artifactId>ShareBikeartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <packaging>jarpackaging>
    <build>
        <sourceDirectory>srcsourceDirectory>
        <resources>
            <resource>
                <directory>srcdirectory>
                <excludes>
                    <exclude>**/*.javaexclude>
                excludes>
            resource>
        resources>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-pluginartifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>main.PushTrailVerticlemainClass>
                        manifest>
                    archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependenciesdescriptorRef>
                    descriptorRefs>
                configuration>
            plugin>
            <plugin>
                <artifactId>maven-compiler-pluginartifactId>
                <version>3.5.1version>
                <configuration>
                    <source>1.8source>
                    <target>1.8target>
                configuration>
            plugin>
        plugins>
    build>
    <dependencies>
        <dependency>
            <groupId>io.vertxgroupId>
            <artifactId>vertx-coreartifactId>
            <version>3.4.2version>
        dependency>
        <dependency>
            <groupId>io.vertxgroupId>
            <artifactId>vertx-webartifactId>
            <version>3.4.2version>
        dependency>
        <dependency>
            <groupId>io.vertxgroupId>
            <artifactId>vertx-web-clientartifactId>
            <version>3.4.2version>
        dependency>
    dependencies>
project>

上面的pom文件需要读者根据自己的项目，做一些修改之后使用。

2，创建一个verticle

package main;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map.Entry;

import entity.Grid;
import impl.GridImpl;
import io.netty.channel.Channel;
import io.netty.channel.EventLoop;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.Vertx;
import io.vertx.core.VertxOptions;
import io.vertx.core.eventbus.DeliveryOptions;
import io.vertx.core.eventbus.EventBus;
import io.vertx.core.eventbus.EventBusOptions;
import io.vertx.core.http.HttpClientOptions;
import io.vertx.core.http.HttpMethod;
import io.vertx.core.http.HttpServer;
import io.vertx.core.http.HttpServerOptions;
import io.vertx.core.http.impl.HttpServerImpl.ServerHandler;
import io.vertx.core.http.impl.ws.WebSocketFrameImpl;
import io.vertx.core.json.JsonArray;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.handler.BodyHandler;
import io.vertx.ext.web.handler.CorsHandler;
import io.vertx.ext.web.handler.sockjs.BridgeOptions;
import io.vertx.ext.web.handler.sockjs.PermittedOptions;
import io.vertx.ext.web.handler.sockjs.SockJSHandler;
import io.vertx.ext.web.handler.sockjs.SockJSHandlerOptions;
import io.vertx.ext.web.impl.RouterImpl;
import util.PropertiesUtil;
import util.ProtoBuilder;
import util.SpatialUtil;

public class PushTrailVerticle extends AbstractVerticle {
    private static JsonArray result;

    public static void main(String[] args) {
        System.out.println("程序启动，开始计算网格");

        JsonArray ja=new JsonArray();
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader("data.txt"));
        } catch (FileNotFoundException e2) {
            e2.printStackTrace();
        }
        String line="";
        try {
            while((line=reader.readLine())!=null){
                ja=new JsonArray(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("网格计算完毕");
        result=ja;
        //想要使用vertx，必须先要创建一个vertx实例
        Vertx vertx=Vertx.vertx();
        //部署verticle
        vertx.deployVerticle(PushTrailVerticle.class.getName());
    }

    @Override
    public void start() throws Exception {
        SockJSHandlerOptions sockjsopt=new SockJSHandlerOptions().setHeartbeatInterval(Integer.parseInt(PropertiesUtil.getProperties("common", "HeartBeatInterval")));//默认25秒，具体查看SockJSHandlerOptions类

        SockJSHandler sockJSHandler = SockJSHandler.create(vertx,sockjsopt);
        //创建路由规则
        Router router=new RouterImpl(vertx);
        BridgeOptions opt=new BridgeOptions();
        opt.setPingTimeout(Integer.parseInt(PropertiesUtil.getProperties("common", "pingTimeout")));//默认10秒，具体查看BridgeOptions类
        int cols=Integer.parseInt(PropertiesUtil.getProperties("common", "cols"));
        int rows=Integer.parseInt(PropertiesUtil.getProperties("common", "rows"));
        for(int i=0;i
            opt.addOutboundPermitted(new PermittedOptions().setAddress("Grid_"+String.valueOf(rows)+"_"+String.valueOf(cols)+"_"+String.valueOf(i+1)));
        }
        //设置从客户端发送消息到服务端的地址，根据自己的需要可以创建任意个
        opt.addInboundPermitted(new PermittedOptions().setAddress("chat.to.server"));
        //解决跨域问题
        router.route().handler(CorsHandler.create("*")
                .allowedMethod(HttpMethod.GET).allowedMethod(HttpMethod.OPTIONS)
                .allowedMethod(HttpMethod.POST).allowedHeader("X-PINGARUNER").allowedHeader("Content-Type"));
        router.route().handler(BodyHandler.create().setBodyLimit(-1));
        router.route("/eventbus/bikeTrail/*").handler(sockJSHandler.bridge(opt,bridgeEvent->{
            switch (bridgeEvent.type()) {
            case SOCKET_CREATED:
                System.out.println(new Date()+":This event will occur when a new SockJS socket is created.");
                break;
            case SOCKET_IDLE:
                System.out.println(new Date()+":This event will occur when SockJS socket is on idle for longer period of time than initially configured.");
                break;
            case SOCKET_PING:
                System.out.println(new Date()+":This event will occur when the last ping timestamp is updated for the SockJS socket.");
                break;
            case SOCKET_CLOSED:
                System.out.println(new Date()+":This event will occur when a SockJS socket is closed.");
                break;
            case SEND:
                System.out.println(new Date()+":This event will occur when a message is attempted to be sent from the client to the server.");
                break;
            case PUBLISH:
                System.out.println(new Date()+":This event will occur when a message is attempted to be published from the client to the server.");
                break;
            case RECEIVE:
                System.out.println(new Date()+":This event will occur when a message is attempted to be delivered from the server to the client.");
                break;
            case REGISTER:
                System.out.println(new Date()+":This event will occur when a client attempts to register a handler.");
                break;
            case UNREGISTER:
                System.out.println(new Date()+":This event will occur when a client attempts to unregister a handler.");
                break;
            default:
//              System.out.println("default");
                break;
            }
            //设置为true，可以处理任何在eventbus上的事件
            bridgeEvent.complete(true);
        }));
        //创建一个eventbus，用来数据通讯
        EventBus eventBus=vertx.eventBus();
        HttpServerOptions httpopt=new HttpServerOptions().setMaxWebsocketFrameSize(Integer.parseInt(PropertiesUtil.getProperties("common", "maxWebsocketFrameSize")));//设置数据量的大小，在数据量小的时候，这个值可以不用设置
        HttpServer server=vertx.createHttpServer(httpopt);
        server.requestHandler(router::accept).listen(8080, res -> {
            if (res.succeeded()) {
                System.out.println("服务开启成功！");
            } else {
                System.out.println("服务开启失败");
            }
        });
        //设置数据推送出去的时间限制
        DeliveryOptions deliveryOptions=new DeliveryOptions(new JsonObject().put("timeout", Integer.parseInt(PropertiesUtil.getProperties("common", "sendtimeout"))));
        //注册地址,然后对接收到客户端来的消息进行处理
        eventBus.consumer("chat.to.server", message -> {
            System.out.println(new Date()+":客户端发往服务端的消息内容为:"+message.body().toString());
            eventBus.publish("Grid_10_10_54", result,deliveryOptions);
            System.out.println(new Date()+":数据发布出去的时间");
        });
        //周期性推送数据
        vertx.setPeriodic(Integer.parseInt(PropertiesUtil.getProperties("common", "PushInterval")), timerID -> {
            eventBus.publish("Grid_10_10_54", result,deliveryOptions);
            System.out.println(new Date()+":推送完毕");
        });
    }
}

3，后端配置参数，即上面的common.properties文件

#推送时间间隔 PushInterval=120000
#心跳间隔(前端设置心跳的时间要小于这个) HeartBeatInterval=10000
#session超时间隔
#SessionTimeout=20000
#bridge_pingTimeout(如果客户端发送数据（无论是Ping还是真实数据）到服务器的时间超过这个阈值就会关闭socket) pingTimeout=30000
#maxWebsocketFrameSize(前端向后端传数据的大小要小于这个参数) maxWebsocketFrameSize=655360
#send message timeout(后端publish数据的时间限制) sendtimeout=1000000

这个里面的参数需要根据自己的项目的实际情况进行配置。

4，PropertiesUtil.java(用来读取属性文件)

package util;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.sql.Clob;
import java.sql.SQLException;
import java.util.Properties;
import java.util.Set;
public class PropertiesUtil {
    public static String getProperties(String propertyname, String sKey) {
        Properties properties = new Properties();
        try {           
            InputStreamReader insReader = new InputStreamReader(new FileInputStream(System.getProperty("user.dir")+"\\"+propertyname+".properties"), "UTF-8");
            properties.load(insReader);
        } catch (IOException e) {
            e.printStackTrace();
        }
        String s = properties.getProperty(sKey);
        return s;
    }
    public static String getProperties(String propertyname) {
        String url = Thread.currentThread().getContextClassLoader().getResource("").toString();
        url = url.substring(url.indexOf("/") + 1);
        url = url.replaceAll("%20", " ");
        Properties properties = new Properties();
        try {
            InputStreamReader insReader = new InputStreamReader(new FileInputStream(url + propertyname + ".properties"),
                    "UTF-8");
            properties.load(insReader);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        String s = properties.toString();
        return s;
    }
    public static Set