vertx初探

背景

vertx是一个我去年看完netty就一直想看看的工具，但因为拖延加懒，最近才看了看文档写了写demo, 算是对它有了一点点了解，之所以想写一点，其实是想自己给自己总结下vertx的一些核心的概念。

vertx core

vertx core 提供了一些 vertx的基本操作，如经常用到的

1. 编写TCP客户端和服务器
2. 编写HTTP客户端和服务器
3. EventBus
4. file操作
5. HA
6. 集群

先上一段代码看下vertx创建一个httpServer:

        //创建一个vertx实例
        VertxOptions vo = new VertxOptions();
        vo.setEventLoopPoolSize( 1);
        Vertx vertx = Vertx.vertx(vo);

        vertx.deployVerticle(MyFirstVerticle.class.getName()); 
        DeploymentOptions().setInstances(2)

        //MyFirstVerticle.java
        public class MyFirstVerticle extends AbstractVerticle {
        public void start() {

        vertx.createHttpServer().requestHandler(req -> {
            System.out.println(Thread.currentThread());
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            req.response()
                    .putHeader("content-type", "text/plain")
                    .end("Hello World!");
            this.deploymentID();
            Context c=vertx.getOrCreateContext();
        }).listen(8080);

    }
}

vertx实例是最核心的一个对象 是宁做几乎一切事情的基础，包括创建客户端和服务器、获取事件总线的引用、设置定时器等等。
是不是很想说一句，嗨，就这，不就nodejs吗

EventLoop

EventLoop算是vertx的基本模型了，简单的讲就是所有的操作都是以 触发 的方式来进行，将IO的操作完全交给vertx,开发者真正要关心的是IO各个阶段的 事件 ，讲的朴素一点就像是js的回调函数一样。
个人觉得vertx的EventLoop 基本等同于Netty的模型，如果真要探索起来，怕是要从Linux的多路复用，select函数，java的NIO，和netty一路将过来了，所以尝试用画图的方式来更形象的描绘：

其实EventLoop 就是一条线程，上面挂的每一个channel就是一个IO连接，底层利用的就是IO多路复用加select 或poll,epoll,来保证每一个线程可以保证控制很多个IO连接，而每一个连接都会挂一个handler，来处理这个连接的 每一个事件 例如：init,connected,read.writer,close。
这个模型的左半部分同样适用于netty。右半部分有一个workPool是一个线程池，是vertx新增的东西，是用来专门处理耗时操作的，如 file,阻塞的DB操作，为什么要加这个概念哪，因为不要阻塞EventLoop是NIO的基本守则。
阻塞操作操作代码如下：

        executor.executeBlocking(future -> {
            System.out.println("Action Thread"+Thread.currentThread());
            // 调用一些需要耗费显著执行时间返回结果的阻塞式API
            String result = blockingMethod("hello");
            future.complete(result);
        }, res -> {
            System.out.println("Handler Thread"+Thread.currentThread());
            System.out.println("The result is: " + res.result());
            executor.close();
        });

verticle

verticle 其实一直是让我困惑的一个概念，因为vertx的主要运行，基本都是围绕vertx实例来进行的，后面我为verticle找到了一个合理的角色，叫他为vertx实例的一个发布单元，什么是一个 发布单元哪，举个例子，一个HttpServer的发布是一个发布单元。
verticle具有以下几个特点：

1. 每个verticle占用一个EventLoop线程，且只对应一个EventLoop
2. 每个verticle中创建的HttpServer,EventBus等等，都会在这个verticle回收时同步回收
3. 在多个verticle中创建同样端口的httpServer，不会有错误，会变成两个EventLoop线程处理同一个HttpServer的连接，所以多核机器，肯定是需要设置多个verticle的实例来加强性能的。

可以这么想，vertx实例就是一台服务器，而verticle就是上面跑的进程。

EventBus

EventBus 是沟通verticle的桥梁，且可沟通集群中不同vertx实例的verticle，操作很简单。这个似乎概念很简单，就是队列呗，上段代码看看：

            //创建一个EventBus
            EventBus eb = vertx.eventBus();

            req.bodyHandler(totalBuffer -> {
                eb.send("news.uk.sport", totalBuffer.toString("UTF-8"));
            });

            //消费
            EventBus eb = vertx.eventBus();
            eb.consumer("news.uk.sport", message -> {
            System.out.println("前台传入的内容：" + message.body()+""+this);
            });

模型如图：

vertx web

vertx core已经提供了基本的HttpServer的操作，但实际上功能远远不够正常的开发，所以vertx web作为一个拓展包，是web开发必须的。他提供了一个基本概念router，来进行各种匹配，使得请求能进入正确的handler，其实就是有点springMvc的各种路径匹配。使用起来代码：

        HttpServer server = vertx.createHttpServer();
 

        Router router = Router.router(vertx);

        router.route("/some/path/").handler(routingContext -> {

            HttpServerResponse response = routingContext.response();
            // 如果不能一次输出所有的response,就需要设置为true
            response.setChunked(true);

            response.write("route1\n");
 
        });
        server.requestHandler(router).listen(8080);

web包括的功能很多，有各种匹配，content-type匹配，路径规则匹配，CROS,错误处理，文件传输 等等

vertx fileSystem

vretx中的文件操作主要采用了javaNio包中的文件操作，通过看源码我们可以发现文件操作也是运行在workPool中的，看下代码：

            fs.copy("C:\\Users\\Administrator\\Desktop\\Untitled-4.txt", "C:\\Users\\Administrator\\Desktop\\ss.txt", res -> {
                System.out.println("file copy handle" + System.currentTimeMillis());
                System.out.println("file copy handle" + Thread.currentThread());
                if (res.succeeded()) {
                    System.out.println("success");
                } else {
                    System.out.println("error");
                }
            })

源码：

    //FileSystemImpl.java

    /**
     * Run the blocking action using a thread from the worker pool.
     */
    public void run() {
      context.executeBlockingInternal(this, handler);
    }

vertx DB

vertx其实提供了 两种数据库操作。一种是正常的jdbc操作，一种是异步非阻塞的数据库操作，但是只限于PG和mysql。

jdbc操作

看一段代码：

JDBCClient client = JDBCClient.createShared(vertx, new JsonObject()
                .put("url", "jdbc:postgresql://localhost:5432/postgres")
                .put("driver_class", "org.postgresql.Driver")
                .put("max_pool_size", 30).put("user","postgres").put("password","postgres"));

client.getConnection(res -> {
                if (res.succeeded()) {
                    SQLConnection connection = res.result();
                    
                    connection.query("SELECT * FROM userb", res2 -> {
                        if (res2.succeeded()) {
                            ResultSet rs = res2.result();
                            System.out.println(rs.toJson());
                        }
                    });
                } else {
                    System.out.println("连接失败");                }
            });

点进去发现：其实做的还是阻塞操作，

    //AbstractJDBCAction.java
    public void execute(Connection conn, TaskQueue statementsQueue, Handler<AsyncResult<T>> resultHandler) {
        this.ctx.executeBlocking((future) -> {
            this.handle(conn, future);
        }, statementsQueue, resultHandler);
    }

异步数据库操作

这我一直很好奇的，因为jdbc在天然上就是阻塞的，所以要想做到数据库的异步，就得放弃厂商提供的driver，自己做一套编解码，看下代码：

PgConnectOptions connectOptions = new PgConnectOptions()
                .setPort(5432)
                .setHost("localhost")
                .setDatabase("postgres")
                .setUser("postgres")
                .setPassword("postgres");

        // Pool options
        PoolOptions poolOptions = new PoolOptions()
                .setMaxSize(5);

        // Create the client pool
        PgPool client = PgPool.pool(vertx, connectOptions, poolOptions);
    
    client.query("SELECT * FROM  userb ", ar -> {
                if (ar.succeeded()) {
                    RowSet<Row> result = ar.result();
                    result.forEach((r) -> response.write((String)r.getValue("name")));
                    response.end();

                } else {
                    System.out.println("Failure: " + ar.cause().getMessage();
                }
            });

这样就能做到数据库的异步操作，且可以包含事务的控制。简直丝滑

关于数据库异步的思考

数据库异步看起来十分黑科技，但是我们应该明白的是，异步非阻塞的NIO最大的优点就在于利用很少的线程来控制更多的IO连接，这使得在超多连接，IO密集的操作中有更好的表现，但是数据库连接本来一个java系统就不会占用几个，记得以前看过一个文章讲连接数设置最好=CPUcore2磁盘数，那么数据库的NIO在一般的业务系统中，似乎并不必要。
插一个知乎上大佬的回答：

https://www.zhihu.com/questio...

vertx模型图

简单明了

vertx的缺点

说到缺点，明显就是回调地狱了，主要还是看过 python的协程，所以难免拿来做个比较，

摘抄自廖雪峰的python教程
import asyncio

from aiohttp import web

async def index(request):
    await asyncio.sleep(0.5)
    return web.Response(body=b'<h1>Index</h1>')

async def hello(request):
    await asyncio.sleep(0.5)
    text = '<h1>hello, %s!</h1>' % request.match_info['name']
    return web.Response(body=text.encode('utf-8'))

async def init(loop):
    app = web.Application(loop=loop)
    app.router.add_route('GET', '/', index)
    app.router.add_route('GET', '/hello/{name}', hello)
    srv = await loop.create_server(app.make_handler(), '127.0.0.1', 8000)
    print('Server started at http://127.0.0.1:8000...')
    return srv

loop = asyncio.get_event_loop()
loop.run_until_complete(init(loop))
loop.run_forever()

可以看到协程 可以将本该做回调的response handler变成了更符合编程习惯的方式，还是比较舒服的。

讲点废话

本来还想把demo放到github上来给像我一样懒的人直接clone下来跑的，但是确实都是官网的例子，放上去太羞耻了。
这文章写的很纠结，写详细了东西太多，写总结性的东西吧，太抽象，没看过的觉得一脸懵，懂得觉得写的没啥意义。
就这吧，如果有大佬想和我讨论或是哪里写的不对，请积极发炎。