vert.x - CSDN
精华内容
参与话题
  • Vertx学习一:这玩意是到底是个啥

    万次阅读 2019-06-22 08:56:13
    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读 原文链接: ... ... 一、Vert.x简介 二、Vert.x原理解析 三、Vert牛刀小试 四、Vert应用实践 五、辅助工...

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    原文链接:

    http://www.360doc.com/content/18/0203/14/39530679_727432611.shtml

     

    目录:

    一、Vert.x简介

    二、Vert.x原理解析

    三、Vert牛刀小试

    四、Vert应用实践

    五、辅助工具

    六、名词解释

    七、后记

    一、Vert.x 简介

    官方文档:http://vertx.io/docs/vertx-core/java/

    Vertx,是一个基于JVM、轻量级、高性能的应用平台,非常适用于移动端后台、互联网、企业应用架构。

    Vertx,基于Netty全异步通信,并扩展出了很多有用的特性。

    Vertx,是基于事件总线设计的高性能架构,保证应用中不同部分以一种非堵塞的线程安全方式通讯。

    Vertx,是借鉴Erlang和Akka架构设计,能充分利用多核处理器性能并实现高并发编程需求的框架。

    Vertx特点

    • 支持多种编程语言

      目前支持Java、JavaScript、Ruby、Python、Groovy、Clojure、Ceylon等,并提供友好的API接口。以上技术栈的工程师可以非常容易的学习和使用Vert.x 架构。

    • 异步无锁编程

      经典的多线程编程模型能满足很多Web开发场景,但随着移动互联网并发连接数的猛增,多线程并发控制模型性能难以扩展,同时要想控制好并发锁需要较高的技巧,目前Reactor异步编程模型开始跑马圈地,而Vert.x就是这种异步无锁编程的一个首选。

      (注:Reactor?文末有解释)

    • 对各种IO的丰富支持

      目前Vert.x的异步模型已支持TCP、UDP、FileSystem、DNS、EventBus、Sockjs等,基本满足绝大多数系统架构需求。

    • 分布式消息传输

      Vert.x基于分布式Bus消息机制实现其Actor模型,我们的业务逻辑如果依赖其他Actor则通过Bus简单的将消息发送出去就可以了。EventBus事件总线,可以轻松编写分布式解耦的程序,具有很好的扩展性。

      EventBus也是Vert.x架构的灵魂所在。

    • 生态体系日趋成熟

      Vertx归入Eclipse基金会门下,异步驱动已经支持了Postgres、MySQL、MongoDB、Redis等常用组件,并且有若干Vertx在生产环境中的应用案例。

    • Vertx是轻量级的

      vertx的核心代码包只有650kB左右,同时提供丰富的扩展插件,满足各类需求。

    • Vertx并不是一个Web容器

      Vertx并不是一个Web Server,它是一种异步编程框架,你可以将自己基于vert.x的应用程序放置到任何你想放置的Web容器中部署运行,可以非常方便的和Spring,Spring Boot,Spring Cloud,Nodejs等语言混编。

    • 模块化

      Vertx本身内置强大的模块管理机制,当你写完一个Vert.x业务逻辑的时候,你可以将其打包成module,然后部署到基于Maven的仓库里,与现有主流的开发过程无缝结合。

    • 支持WebSocket

      支持WebSocket协议兼容SockJS , 可以非常方便的实现web前端和服务后端长连接通信,是轻量级web聊天室应用首选解决方案。

    • 使用简单

      这里的简单意味着你编写的代码是完全基于异步事件的,类似Node.JS,与此同时.你不需要关注线程上的同步,与锁之类的概念,所有的程序都是异步执行并且通信是无阻塞的。

    • 良好的扩展性

      因为基于Actor模型,所以你的程序都是一个点一个点的单独在跑,一群点可以组成一个服务,某个点都是可以水平扩展,动态替换,这样你的程序,基本就可以达到无限制的水平扩展。

    • 高并发性

      vert.x是一个事件驱动非阻塞的异步编程框架,你可以在极少的核心线程里占用最小限度的硬件资源处理大量的高并发请求。

      此并发并非JDK库的并发,当你Coding的时候,不再关注其锁,同步块,死锁之类的概念,你就可以随性所欲的写自己的业务逻辑,Vert.x本身内置三种线程池帮你处理。

    目前,该框架国内用的还不太多,但是国外比较多,如英孚教育、Hulu、以及做JVM监控的一家公司jClarity等。Google group上的话题也比较多,非常活跃,属于技术极客圈里热门话题。

    如果你是技术小白,可以通过学习Vertx拓宽你的技术栈;如果你是架构师,可以借鉴Vertx的架构设计思路,更好的提升自我的架构能力,也为公司未来的技术选型,多一种选择和考量。

    二、Vertx原理解析

    本小节主要讲一些理论性的东西,核心是想讲明白Vertx的体系结构,verticle和vertx的关系,以及verticles 之间是如何通信和运行的,很枯燥的一章。建议大家先大体看看,不用立刻理解(也不可能),带着疑问继续读后面的几个章节。

    Vertx应用在很大程度上是通过定义事件处理程序。应用之间通过事件总线传递消息,异步响应。

    Vertx的编程框架可以简单的理解为:

    • verticle是vert.x中可被部署运行的最小代码块,可以理解为一个verticle就是一个最小化的业务处理引擎。 一个应用程序可以是单个verticle或者由EventBus通信的多个verticles构成。

      verticle被发布部署后,会调用其内部的start方法,开始业务逻辑处理,完成后会调用stop方法,对该代码块执行销毁动作。

    • Verticles在Vert.x实例中运行。 一个Vertx可以承载多个verticles,每个Vert.x实例在其私有的JVM实例运行。 一台服务器可以运行一个或多个Vert.x实例(建议运行Vertx实例的数量和CPU核数正相关)。

    • 一个Vert.x实例,保证其承载的verticles实例总是在同一个线程执行, 并发Vert.x 是单线程的。

    • 在内部,Vert.x实例维护一组线程(通常为CPU核心数)是在执行一个事件循环。

    • 虽然你可能会认为,共享数据和可扩展性截然相反。 Vert.x提供了一个共享的MAP和跨在同一Vert.x实例中运行verticles传递不可改变的数据共享一套设施,这时候数据是可变的唯一真正的 。

    • Vert.x使用相对较少的线程来创建一个事件循环和执行verticles。 但在某些情况下,需要verticle做一些要么昂贵计算,或可能阻塞,如连接到数据库。 当发生这种情况Vert.x可以让你标记verticle实例作为worker verticle 。

    • Vert.x确保worker verticles将永远不会被同时执行。

    1、Vert.x系统的体系结构

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    2、客户端请求处理流程

    请求在vert.x框架中被插入到一个事件队列中,耗时的任务将被委托给长任务处理线程进行处理,保证线程不被耗时的IO操作进行阻塞等待。

    如下图:

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    3、EventBus通信模型

    事件循环线程和长任务处理线程通过EventBus进行通信。

    如下图:

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    4、部分名词对照表:

    • handler

      事件处理器

    • event loop

      事件循环(线程)

    • verticle

      Vert.x的专有名词。指代Vert.x中基本的功能单元,一个Vert.x应用应该是由一组verticles构成的。

    • worker

      顾名思义,干活的(线程)。对应文档中有worker thread pool,worker verticle(Vert.x里的work verticle与标准版verticle区别较大)。

    • event bus

      事件总线

    Vert.x核心功能是最底层且相当简洁的,没有诸如数据库存取、认证、高级web等功能,你可以在Vert.x ext(扩展包)找到以上这些组件。

    5、Vert.x Core提供的功能

    • 编写TCP客户端和服务器

    • 编写 HTTP 客户端和服务器包括 Websocket 支持

    • 事件总线(Event bus)

    • 共享的数据-本地的map和分布式的map

    • 定时和延时运行

    • 部署和非部署 Verticles

    • Sockets

    • DNS 客户端

    • 文件系统

    • 高可用性

    • 集群

    三、Vertx 的牛刀小试

    本节将教你如何一步一步地创建第一个vert.x应用程序。

    1、基础环境:

    • Vertx.x支持的操作系统

      Linux、OSX和Windows

    • JDK

      Vertx.x需要JDK7以上版本,可以选择Oracle JDK或OpenJDK。

      (如果使用非java版Vertx,无需JDK,只需要对应开发语言的安装包就好,本文以Java版为基础进行讲解)

    2、创建vert.x应用程序

    • 在pom.xml中增加:

    <dependency>

    <groupId>io.vertx</groupId>

    <artifactId>vertx-core</artifactId>

    <version>3.2.0</version>

    </dependency>

    • 创建Verticle

      Verticle实例是一个自定义的Verticle类的对象,自定义的Verticle实例需要继承AbstractVerticle类,如下所示,创建自定义 Verticle 即MyVerticle

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    Verticle有两个有用的方法:

    start()和stop()

    这两个方法在Verticle实例被注册的Vertx实例或者从Vertx实例卸载的时候被自动调用。

    你可以在start()里加入一些需要做的工作,并且在stop里加入一些需要清理的工作。

    • 注册Verticle实例到Vertx实例

      Vertex对象是Vert.x的控制中心,创建客户端和服务器、获取事件总线(event bus)的引用、设置定时器等功能都需要该实例。

      该Vertx实例,其实并不能做具体事情。为了让程序能做一些有用的事情,需要将自定义的MyVerticle实例注册到Vertx。

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    Vertx提供两种注册方法:

    1. 通过传递一个Verticle实例参数(如本例使用)

    2. 通过包名称进行注册(如本例注释部分)

    • 测试运行效果

      在IDE 中启动VertStart,控

    • 制台输出

    MyVerticle started!

    到此,你已经完成了第一个 vert应用程序的创建和使用。

    在下一节,我们将扩展开讲解vert的常规应用,通过这一节的学习,你将深入认识vert的开发模式。

    四、Vert应用实践

    上一小节,我们实现了第一个vert程序,本小节将更多更全面的展示vert的使用方法。

    1、搭建Vert.x Web服务器代码示例

    • pom.xml文件引入web扩展包

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    • RestfulVerticle.java

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    • 启动RestfulVerticle.java

      浏览器访问

    http://localhost:8080/get/1/2

    或 终端执行

    crul http://localhost:8080/get/1/2

    返回内容:

    {

    'method' : 'get',

    'param1' : '1',

    'param2' : '2'

    }

    浏览器访问

    http://localhost:8080/assets/

    返回页面

    index.html

    解析:

    HttpServer:

    http/https/websockets服务器,vert.x发布restful服务,不需要tomcat提供servlet容器,它自己就是一台性能强大的web服务器,并且原生支持负载均衡,后面我们会讲到。

    Router类:

    Router类可以理解为一个路由器,他接收httpserver带来的请求,并将不同的请求分发到不同的路由中,如果简单对比一下spring mvc的话,可以将router理解为spring mvc中的dispatcher。

    route:

    route代表一条路由,同样,对比spring mvc,相当于spring中的@RequestMapping,他指定了restful api的请求接口路径,并将其交给handler来处理该条路由。

    Handler:

    handler处理具体的路由请求,字面上讲就是处理某个具体的restful api。他与httpserver,router,route的关系可以用如下流程表示:

    来自httpserver的request请求-->交由路由器做分发处理-->路由器匹配到具体的路由规则-->路由到最终的handler去处理请求

    vert.x默认提供了很多处理器,包括但不局限于以下:

    AuthHandler 处理权限校验支持

    BodyHandler 提供所有请求上下文

    CookieHandler 提供cookie支持

    SessionHandler 提供session支持

    RoutingContext:

    请求上下文,可以理解为servlet中的httprequest和httpresponse

    RestfulVerticle.java的start方法里创建了一个Router对象。

    router是Vert.x Web的基础,负责分发HTTP请求到handler(处理器),在Vert.x Web中还有两个很重要的概念。

    • Routes-定义请求的分发

    • Handlers-这是实际处理请求并且返回结果的地方。Handlers可以被链接起来使用。

    router::accept,它表示引用一个方法(这里是引用router的accept方法)。当接收到一个请求的时候,告诉vert.x从router里调用accept方法。

    将访问“/assets/*”的请求,route到“assets”目录下的资源,默认访问index.html。

    2、处理session代码示例

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    访问:http://localhost:8080/ 计数器 1返回。

    3、处理cookies代码示例

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    访问:http://localhost:8080/ 计数器 1,返回。

    4、Vert.x通信

    为了建立一个Vert.x消息系统,需要启动vertx实例的eventBus()方法,从而获得该事件总线。

    EventBus eb = vertx.eventBus();

    Vertx提供两种发布消息的方式

    • publish()

      发布消息到特定地址,所有订阅该地址消息的服务都可以接收到消息。该地址只是一个字符串。

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    • send()

      发送消息到特定地址,如果多个服务都注册到该地址,将只有一个订户会接收到该消息。

      两个组件要异步地相互通信时,使用该方式。

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    代码示例

    接收消息:

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    注册handlers

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    当收到一条消息时,handler会被调用,而消息(message)会作为参数传递过去。

    其中 news.uk.sport 表示消息的注册地址,消息发布者在也要注册到该地址。

    当在一个集群event bus上注册了handler时,完成在集群上每个节点的注册需要花点时间。

    如果你想在完成时得到通知,你可以在MessageConsumer 对象上注册一个completion handler

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    发布消息

    eventBus.publish('news.uk.sport', 'Yay! Someone kicked a ball');

    这个消息会被分发到注册在地址 news.uk.sport 上的所有handlers。

    如果想点对点的发布消息即只有一个接收到消息,可以使用send方法

    eventBus.send('news.uk.sport', 'Yay! Someone kicked a ball');

    使用send方法时event bus会尝试把消息发送到注册在event bus上的MessageConsumer对象。

    某些情况下,发送方可能想知道消息已经被接收并处理了。

    为了让发放方了解消息已被处理,consumer可以通过调用reply方法给予回应。

    如果这么做了,那么发送方将会收到一个回应,并且回应handler将被调用。看下面这个例子:

    接收方:

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    发送方:

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    5、定期、延时执行

    在标准verticle里,你不能以使线程休眠的方式引入延迟;这样干会阻塞event loop线程.

    取而代之的是Vert.x定时器,定时器分为一次性(one-shot)和周期性(periodic)

    为一次性定时器:

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    周期性:

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    如果你是在verticle内部创建的定时器,那么verticle被卸载时,这些定时器将被自动关闭。

    (注意:定时器会定期触发。如果你的定期处理需要耗费大量时间,你的定时器事件可能会连续运行甚至糟糕到堆积在一起。在这种情况下,你应该考虑转而使用setTimer。一旦你的处理完成了,你可以再设置下一个定时器。)

    五、辅助工具

    Vert.x3常用工具

    最后在提一下几个Vert.x3的一些小工具。

    1. metrics

      这个可以用来统计整个Vert.x内部的一些指标信息,比如HTTP请求数,TCP接受或者发送的流量等等,具体可以看官方文档,通过这个接口我们可以实时的统计Vert.x内部性能信息。

    2. vertx-test-unit

      Vert.x提供了专门针对异步代码的单元测试框架。

      通过redeploy这个参数可以动态的热部署整个verticle,这个对开发调试时非常有用。

    3. EventLoopChecker

      Vert.x3内置了EventLoopChecker这个动态监测所有EventLoop线程的工具,默认EventLoop被阻塞了2秒钟的时候会触发报警,如果持续阻塞则会直接打印那一块的异常栈到日志里,非常方便开发者来检查自己的异步代码。

    六、名词解释

    Reactor模式

    和传统Java框架的多线程模型相比,Vert.x Netty是 Reactor模式的Java实现。考古了一下Reactor模式, 其理论最早由Washington University的Douglas C. Schmidt教授在1995年提出,在《Proactor - An Object Behavioral Pattern for Demultiplexing and Dispatching Handlers for Asynchronous Events 》这篇论文中做了 完整介绍。

    图1-6是对其关键原理部分展开分析。

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    图1 一个经典Web Server在收到Web浏览器请求后的处理过程

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    图2 一个经典Web Server使用多线程模型,并发处理来自多个Web浏 览器的请求

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    图3 Web浏览器连接到一个Reactor模式的Web Server处理过程。利 用了Initiation Dispatcher组件,把耗时的IO操作事件注册到Initiation Dispatcher组件

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    图4 Web浏览器访问一个Reactor模式的Web Server处理过程。耗时IO 操作由其它线程执行,IO执行完成后通知Initiation Dispatcher,再回到 Http Handler执行

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    图5 Web浏览器连接一个Proactor模式的Web Server处理过程。和Reactor的主要区别是耗时IO操作交给操作系统异步IO库执行(例如 GNU/Linux aio),操作系统异步IO库执行完毕后,通过异步IO通知机制(例如epoll)触发Completion Dispatch,再交给Http Handler执行

    Vertx,融合Java、Ruby、Python等语言的高性能架构,架构师必读

    图6 Web浏览器访问一个Proactor模式的Web Server处理过程。和Reactor的主要区别是耗时IO操作交给操作系统异步IO库执行(例如 GNU/Linux aio),操作系统异步IO库执行完毕后,通过异步IO通知机制(例如epoll)触发Completion Dispatch,再交给Http Handler执行

    事实上,Vert.x/Netty的Reactor实现部分是在Netty 4.0如上述所示的代码中实现,和上述图中能对应的几个类是io.netty.channel.nio.NioEventLoop,io.netty. channel.epoll.EpollEventLoop,java.nio.channels.spi.SelectorProvide

    七、后记

    Vertx是什么,有哪些特点,以及基本使用方法,本文做了基本的介绍。

    作为一个优秀的异步通信框架,Vertx还有非常多的高级应用和完整的生态体系。在后面的文章中,我会为大家持续解开Vertx的神秘面纱。

    本文演示所用源码下载地址:

    https://github.com/wzjgn/Vertx.git

    展开全文
  • vert.x详细介绍,全异步框架

    千次阅读 2018-03-06 14:24:55
    Vert.x是一个基于JVM、轻量级、高性能的应用平台,非常适用于最新的移动端后台、互联网、企业应用架构。Vert.x基于全异步Java服务器Netty,并扩展出了很多有用的特性github: https://github.com/vert-x3官网:...

    Vert.x是一个基于JVM、轻量级、高性能的应用平台,非常适用于最新的移动端后台、互联网、企业应用架构。Vert.x基于全异步Java服务器Netty,并扩展出了很多有用的特性


    github:  https://github.com/vert-x3

    官网http://vertx.io/

    介绍:

    Vert.x诞生于2011年,当时叫node.x,不过后来因为某些原因改名位Vert.x。经过三年多的发展,现在已经到了3.3.3版本,社区也越来越活跃,在最新的官网Vertx.io上,作者用一句话介绍了它,JVM上的Reative开发套件。Vert.x目前是见过最功能最强大,第三方库依赖最少的Java框架,它只依赖Netty4以及Jacskon,另外如果你需要建立分布式的Vert.x则再依赖HazelCast这个分布式框架,注意Vert.x3必须基于Java8。由于基于JVM,所以Vert.x可以用其他语言来实现你的业务。

    Vert.x是一个异步无阻塞的网络框架,其参照物是node.js。基本上node.js能干的事情,Vert.x都能干。Vert.x利用Netty4的EventLoop来做单线程的事件循环,所以跑在Vert.x上的业务不能做CPU密集型的运算,这样会导致整个线程被阻塞。


    特性:

    1、同时支持多种编程语言——目前已经支持了Java、Scala、JavaScript、Ruby、Python、Groovy、Clojure、Ceylon等。对程序员来说,直接好处就是可以使用各种语言丰富的LIB,同时也不再为编程语言选型而纠结;

    2、异步无锁编程——经典的多线程编程模型能满足很多Web开发场景,但随着移动互联网并发连接数的猛增,多线程并发控制模型性能难以扩展,同时要想控制好并发锁需要较高的技巧,目前Reactor异步编程模型开始跑马圈地,而Vert.x就是这种异步无锁编程的一个首选;

    3、对各种IO的丰富支持——目前Vert.x的异步模型已支持TCP、UDP、FileSystem、DNS、EventBus、Sockjs等;

    极好的分布式开发支持——Vert.x通过EventBus事件总线,可以轻松编写分布式解耦的程序,具有很好的扩展性;

    4、生态体系日趋成熟——Vert.x归入Eclipse基金会门下,异步驱动已经支持了Postgres、MySQL、MongoDB、Redis等常用组件,并且有若干Vert.x在生产环境中的应用案例。


    Vert.x是基于事件的,提供一个事件驱动编程模型,使用Vert.x作为服务器时,程序员只要编写事件处理器event handler即可. 当TCP socket有数据时,event handler理解被创建调用,另外它还可以在以下几种情况激活: '当事件总线Event Bus接受到消息时,' '当接收到HTTP消息时,' 当一个连接断开时',' '当计时器超时时.'

    作为服务层处理逻辑这一层基本上对应的传统Java里的领域模型处理层.各种Service调用,以及对数据层的调用.差不多是一个承上启下的一层.传统的模型里,这一层基本上都是同步调用,即使有异步调用,也是与业务逻辑分离的异步.如果全异步会导致业务逻辑碎乱.代码很难描述清楚.到这里你会发现Vert.x其实不太好融合到业务性很强的服务层里.其主要原因如下
    1、自身是异步体系,不适合描述顺序逻辑性强的业务
    2、由于异步的问题,访问数据层也必须是异步,导致业务模型进一步碎片化.


    Vert.x的执行单元叫verticle。即程序的入口,每个语言可能实现的方式不一样,比如Java需要继承一个AbstractVerticle抽象类

    verticle分两种,一种是基于EventLoop的适合I/O密集型的,还有一种是适合CPU密集型的worker verticle。而verticle之间相互通信只能通过Eventbus,可以支持point to point 的通信,也可以支持publish & subscribe通信方式。


    重要的接口
    org.vertx.java.core.Handler

    Vert.x运行时的核心接口, 用于结果回调处理,你大部分的逻辑代码都会在这里执行.所以无需解释.

    org.vertx.java.core.Context
    这个名词的含义就是一个基于Vert.xAPI搭建起来的可运行的程序.这里我们就简单的理解继承了org.vertx.java.platform.Verticle的Java类或者其他语言的脚本

    那Context接口就代表着一次可执行单元的上下文,这里的上下文只干一件事情就是处理Handler里的内容void runOnContext(Handler<Void> action);,

    在Vert.x里有两种上下文,即EventLoop与Worker,而Worker又会分按顺序执行的Worker与多线程Worker.这里我们就先看成两类EventLoop与Worker,什么是EventLoop呢.
    在Vert.x里所有的事件包括IO都是依赖于Netty的EventLoop接口,而这个接口在Netty里会一定的频率调用.即当发生IO事件时,Netty会按时间比率分配CPU资源去响应这个事件.
    在Vert.x里你可以简单的理解为IO相关的事件就可以了,用了一个特定的线程池来响应这类请求.而Worker在Vert.x里默认是一套按顺序执行的Handler,即按照先来先到的顺序依次执行,此类的请求是另一个线程池执行.


    所有业务逻辑其实都会跑在Netty里的EventLoop上,而EventLoop通过循环事件队列来执行所有的业务逻辑,这样可以把一些I/O操作频繁的事件及时从CPU上剥离开来,最后通过注册一个回调Handler来处理所有的事件回调


    org.vertx.java.core.Vertx
    这个其实就是API,非Vert.x扩展者,能用到的所有的东西都在这里了.基于上面的三个接口,其实就能抽象出一个异步的模型,通过Vertx接口调用一个API,API内部会持有一个Context,在API本身的非业务逻辑执行完后,将Handler传入Context执行.这大概就是整个Vert.x内部执行的流程,三个接口抽象出一个世界这便是软件设计的哲学.

    重要概念

    Verticle

    基于Vert.x框架实现的代码包,就是一个Verticle,简单点说,一个可以被Vert.x框架执行的代码调用了Vert.xAPI的代码就是一个Verticle.他可以用Scala Clojure JS Ruby等语言实现.多个Verticle实例可以并行的被执行.一个基于Vert.x的服务也许需要多个verticles来实现,而且要部署在多台服务器上.他们之间通过vert.x事件进行通信.你可以之间通过vert.x命令启动,也可以将verticle包装成vert.x modules.

    Module

    Vert.x应用由一个或多个modules来实现.一个模块呢由多个verticles来实现.你可以把module想象出一个个Java package.里面可能是特定业务的实现,或者公共的服务实现(那些可以重用的服务).Vert.x编写好的module,可以发布到maven的仓库里.以zip包装成二进制格式.或者发布到vert.x module 注册中心.实际上这种以模块方式的开发,支撑着整个Vert.x生态系统.Module更多的信息,我需要单独开一个系列来讲解.

    Event Bus

    它是Vert.X的核心,在集群中容器之间的通信,各个Verticle之间的通讯都是经过Event Bus来实现的,后期会推出一篇专门关于这个的文章,敬请等待。

    Shared Data

    它是Vert.X提供的一个简单共享Map和Set,用来解决各个Verticle之间的数据共享

    框架图


    实例:

    [java] view plain copy
    1. public class HelloWorldEmbedded {  
    2.     public static void main(String[] args) {  
    3.         // Create an HTTP server which simply returns "Hello World!" to each request.  
    4.         Vertx.vertx().createHttpServer().requestHandler(req -> req.response().end("Hello World!")).listen(8080);  
    5.       }  
    6.   
    7. }  

    启动一个verticle

    [java] view plain copy
    1. vertx.deployVerticle(DingtalksrvVertical.class.getName(), deploymentOptions, result -> {  
    2.           if (result.succeeded()) {  
    3.             String deployId = result.result();  
    4.             System.out.println("Dingtalksrv 部署成功 [" + deployId + "]");  
    5.             future.complete();  
    6.           } else {  
    7.             System.out.println("Dingtalksrv 部署失败  " + result.cause().getMessage());  
    8.             future.fail(result.cause());  
    9.           }  
    10.         });  

    启动服务

    [java] view plain copy
    1. HttpServerOptions options = createOptions();  
    2.     server = vertx.createHttpServer(options);  
    3.     server.requestHandler(mainRouter::accept);  
    4.     server.listen(result -> {  
    5.       if (result.succeeded()) {  
    6.           
    7.       } else {  
    8.          
    9.       }  
    10.     });  
    11. mainRouter = Router.router(vertx);  
    12. mainRouter.mountSubRouter("/api", router);  
    13. Router router = Router.router(vertx);  
    14. router.route(HttpMethod.POST, "/hello").handler(HelloHandler()::handleRequest);  


    异步封装

    [java] view plain copy
    1. executor.executeBlocking((Future<T> f) -> {  
    2.       try {  
    3.           jdbc_routine();  
    4.         }  
    5.         f.complete();  
    6.       } catch (SQLException e) {  
    7.         f.fail(e);  
    8.       }  
    9.     }, handler);  

    Vert.x3支持很多常用工具:metrics、热部署、consul、kafka、mongo、redis等

    有兴趣可以到github上查看相应组件

    Vert.x的执行单元叫verticle。即程序的入口,每个语言可能实现的方式不一样,比如Java需要继承一个AbstractVerticle抽象类

    verticle分两种,一种是基于EventLoop的适合I/O密集型的,还有一种是适合CPU密集型的worker verticle。而verticle之间相互通信只能通过Eventbus,可以支持point to point 的通信,也可以支持publish & subscribe通信方式。

    展开全文
  • Vert.x(vertx) 简明介绍

    万次阅读 多人点赞 2019-03-12 13:23:01
    Vert.x最大的特点就在于异步(底层基于Netty),通过事件循环(EventLoop)来调起存储在异步任务队列(CallBackQueue)中的任务,大大降低了传统阻塞模型中线程对于操作系统的开销。因此相比较传统的阻塞模型,异步...

    摘要

    Vert.x最大的特点就在于异步(底层基于Netty),通过事件循环(EventLoop)来调起存储在异步任务队列(CallBackQueue)中的任务,大大降低了传统阻塞模型中线程对于操作系统的开销。因此相比较传统的阻塞模型,异步模型能够很大层度的提高系统的并发量。

    Vert.x除了异步之外,还提供了非常多的吸引人的技术,比如EventBus,通过EventBus可以非常简单的实现分布式消息,进而为分布式系统调用,微服务奠定基础。除此之外,还提供了对多种客户端的支持,比如Redis,RabbitMQ,Kafka等等。

    Vert.x异步也带来了编码上的复杂性,想要编写优美的异步代码,就需要对lambda表达式、函数式编程、Reactive等技术非常熟悉才行,否则很容易导致你的代码一团糟,完全没有可读性。另外,异步模型的性能调优、异常处理与同步模型有很大差异,网络中相关资料较少,使用中遇到问题排查困难,这也是目前国内架构师不愿意选择Vert.x的原因。

    Vert.x运行在Java虚拟机上,支持多种编程语言,Vert.x是高度模块化的,同一个应用,你可以选择多种编程语言同时开发。在Vert.x 2版本,也就是基于JDK7,还没有lambda的时候,一般来讲,使用JavaScript作为开发语言相对较多,到Vert.x3的时代,因为JDK8的出现,Java已经作为Vert.x主流的开发语言,而Vert.x也被更多的开发者所接受。

     

    本篇主要从五个方面对Vert.x进行介绍

    1. Vert.x能干什么

    2. Vert.x快速体验

    3.Vert.x的简单介绍

    4.Vert.x的一些优势

    5.Vert.x的技术体系

    1. Vertx能干什么

    Java能做的,Vert.x都能做。主要讨论,Vert.x善于做哪些事情!

    (1)Web开发,Vert.x封装了Web开发常用的组件,支持路由、Session管理、模板等,可以非常方便的进行Web开发。不需要容器!不需要容器!不需要容器!

    (2)TCP/UDP开发,Vert.x底层基于Netty,提供了丰富的IO类库,支持多种网络应用开发。不需要处理底层细节(如拆包和粘包),注重业务代码编写。

    (3)提供对WebSocket的支持,可以做网络聊天室,动态推送等。

    (4)Event Bus(事件总线)是Vert.x的神经系统,通过Event Bus可以实现分布式消息,远程方法调用等等。正是因为Event Bus的存在,Vert.x可以非常便捷的开发微服务应用。

    (5)支持主流的数据和消息的访问
        redis mongodb rabbitmq kafka 等

    (6)分布式锁,分布式计数器,分布式map的支持

    2. 快速体验

    下面实现一个HttpServer,实现使用浏览器访问,给浏览器返回一个 SUCCESS的功能来快速感受下Vert.x。下面这个类可以直接运行,而不需要使用tomcat进行部署,就可以直接通过浏览器来进行访问。非常类似于nodejs,但是比nodejs的性能要高很多。请求的地址为:http://localhost。更详细的例子可以参考Vert.x 创建HTTP服务

    public class MyHttpServer extends AbstractVerticle {
    
    	public static void main(String[] args) {
    		// 创建服务
    		MyHttpServer verticle = new MyHttpServer();
    		Vertx vertx = Vertx.vertx();
    
    		// 部署服务,会执行MyHttpServer的start方法
    		vertx.deployVerticle(verticle);
    	}
    
    	@Override
    	public void start() throws Exception {
    		// 在这里可以通过this.vertx获取到当前的Vertx
    		Vertx vertx = this.vertx;
    
    		// 创建一个HttpServer
    		HttpServer server = vertx.createHttpServer();
    
    		server.requestHandler(request -> {
    			// 获取到response对象
    			HttpServerResponse response = request.response();
    
    			// 设置响应头
    			response.putHeader("Content-type", "text/html;charset=utf-8");
    
    			// 响应数据
    			response.end("SUCCESS");
    
    		});
    
    		// 指定监听80端口
    		server.listen(80);
    	}
    }

    3. 什么是Vert.x

    简单说,Vert.x就是一堆的jar包,提供了一系列的编程API接口。通过这些API,可以实现异步编程

    快速理解异步编程

    什么是异步编程?异步编程是Vert.x的一大特性,也是Vert.x的核心,异步编程非常好理解,写过ajax吗,看下面代码,$.ajax方法并不会阻塞,而是直接向下执行,等到远程服务器响应之后,才会回调success方法,那么这时候success方法才会执行。ajax下面的代码不会等到success方法执行完毕之后再执行,这就是所谓的异步。

    console.log("1");
    
    $.ajax({
    	"url" : "/hello",
    	"type" : "post",
    	"dataType" : "json",
    	"success" : function(val) {
    		console.log("2");
    	}
    });
    
    console.log("3");

    Vert.x可以开发Web应用,但Vert.x不仅仅是一个Web开发框架,他更像Spring,是一个技术栈(Vert.x生态可以查看https://github.com/vert-x3/vertx-awesome),或者说是一个Vert.x生态体系。在这个体系中,Vert.x只是提供了Web开发的能力。下面对Vertx和Spring做一个对比:

    项目 Spring Vertx
    核心框架 spring-core vertx-core
    Web开发 spring-webmvc vertx-web
    jdbc框架 spring-jdbc vertx-jdbc-client
    redis spring-data-redis vertx-redis-client
    微服务 spring-cloud vertx-hazelcast

    可以说,很多的spring能做的事情,Vertx也都能实现。那么既然如此,Spring如此强大,社区如此活跃,为何还会有Vertx呢?他们之前区别的核心点就只有一个,Spring的操作是同步的,Vertx的操作是异步的。异步带来了更高的性能,但同时也带来了编码和调试的复杂度,但不得不说异步可能是未来的一个趋势,至少在Java实现高性能服务器上的一个趋势。

    在Java领域,做Web开发我们一般有很多的选择,比如使用原生的Servlet,比如使用SpringMVC,再比如使用Struts等等总之你有很多的选择。在国内,目前来讲,SpringMVC作为Spring体系下的Web层架构,是深受企业青睐的,绝大部分的企业可能都在使用SpringMVC。而对于我们今天要说的Vert.x这个Web层框架,却很少有人知道,但它却是仅次于SpringMVC,排名第二的一个Web层框架。

    4. Vert.x的一些优势

    (1)异步非阻塞

    Vert.x就像是跑在JVM之上的Nodejs,所以Vert.x的第一个优势就是这是一个异步非阻塞框架。上面也提到了异步,我们使用ajax来演示的异步,下面使用Vert.x请求远程地址一个代码,可以看到和ajax非常像!

    System.out.println("1")
    
    WebClient
        .create(vertx)
        .postAbs(REQUEST_URL) // 这里指定的是请求的地址
        .sendBuffer(buffer, res -> { // buffer是请求的数据
    
            if (res.succeeded()) {  
                // 请求远程服务成功
                System.out.println("2")
                
            } else {
                // 请求失败
                resultHandler.handle(Future.failedFuture("请求服务器失败..."));
            }
        });
    
    System.out.println("3")

    这段代码的执行效果和上面的JavaScript执行的结果是类似的,同样是先打印 1,再打印 3,最后打印 2。

    异步也是Vert.x于其他的JavaWeb框架的主要区别。我们这里先不去讨论异步的优势与他的实现原理,只要先知道,Vert.x和JavaScript一样,是一个异步执行的就可以了。

    Vert.x和JDK8

    Vert.x必须运行在JDK8上,JDK8提供了lambda表达式,可以简化匿名内部类的编写,可以极大的挺高代码的可读性。

    上面的代码中看到 在 sendBuffer 这一行里有一个 -> 这种形式。这个是Java代码吗? 是的。是JDK8提供的lambda表达式的形式。用于简化匿名内部类的开发。有兴趣的朋友可以了解一下lambda表达式,在使用Vertx进行项目开发时有大量的匿名内部类,因此很多情况会用到。

    (2)Vertx支持多种编程语言

    Vert.x有一个口号大概是:“我们不去评判那个编程语言更好,你只要选择你想要使用的语言就可以了”。也就是说,在Vert.x上,可以使用JavaScript,Java,Scala,Ruby等等,下面是官网的一个截图

    (3)不依赖中间件

    Vert.x的底层依赖Netty,因此在使用Vert.x构建Web项目时,不依赖中间件。像Node一样,可以直接创建一个HttServer。就像我们上面第一个例子,可以直接运行main方法,启动一个Http服务,而不需要使用类似于Tomcat的中间件。不依赖中间件进行开发,相对会更灵活一些,安全性也会更高一些。

    (4)完善的生态

    Vert.x和Spring的对比,有一种使用MacOS和Windows对比的感觉。Vert.x和庞大的Spring家族体系不同,Vert.x提供数据库操作,Redis操作,Web客户端操作,NoSQL数据库的一些操作等常用的结构,很清新,很简洁,但足够使用。下面是从官网截取的一个提供的客户端工具。

    (5)为微服务而生

    Vert .x提供了各种组件来构建基于微服务的应用程序。通过EventBus可以非常容易的进行服务之间的交互。并且提供了HAZELCAST来实现分布式。

    当然了,除了一些优势以外,要在项目中选择使用Vert.x还要考虑一些问题,这里不展开说明,只是根据个人的使用经验提出一些点。

    * Vert.x使用JDK8的Lambda,所以要使用Vert.x首先需要对JDK8比较熟悉。当然,对于一个开发者,现在JDK已经出到JDK11了,JDK8的特性也理应该学习一下

    * 对于复杂的业务,可能会遇到Callback Hell问题(解决方案也有很多)

    * 由于异步的特征、契约创建、更高级的错误处理机制使得开发过程会相对更复杂。(来自并发编程网)

    5. Vert.x技术体系

    上面也提到了,Vert.x和Spring一样,也有着完善的生态,具体可以查看https://github.com/vert-x3/vertx-awesome 我们可以看到,每一块内容都提供了多种的实现,有官方支持的版本还有社区版本。下面我们具体介绍下技术体系中官方支持的版本。

    (1)核心模块

    Vert.x核心模块包含一些基础的功能,如HTTP,TCP,文件系统访问,EventBus、WebSocket、延时与重复执行、缓存等其他基础的功能,你可以在你自己的应用程序中直接使用。可以通过vertx-core模块引用即可。

     (2)Web模块

    Vert.x Web是一个工具集,虽然核心模块提供了HTTP的支持,但是要开发复杂的Web应用,还需要路由、Session、请求数据读取、Rest支持等等还需要Web模块,这里提供了上述的这些功能的API,便于开发。

    除了对Web服务的开发以外,还提供了对Web客户端请求的支持,通过vertx-web-client即可方便的访问HTTP服务。有朋友可能会有疑惑,我明明可以使用JDK提供的URL来请求HTTP服务啊。使用Vert.x一定要注意,Vert.x是一个异步框架,请求HTTP服务是一个耗时操作,所有的耗时,都会阻塞EventBus,导致整体性能被拖垮,因此,对于请求Web服务,一定要使用Vert.x提供的vertx-web-client模块

     (3)数据访问模块

    Vert.x提供了对关系型数据库、NoSQL、消息中间件的支持,传统的客户端因为是阻塞的,会严重影响系统的性能,因此Vert.x提供了对以上客户端的异步支持。具体支持的数据访问如下:

    MongoDB client,JDBC client,SQL common,Redis client,MySQL/PostgreSQLclient

     (4)Reactive响应式编程

    复杂的异步操作,会导致异步回调地狱的产生,看下面的代码,这是我在Vert.x提供的例子中找到的,我们不去管这段代码干了啥,只是看后面的}就很惊讶了,如果操作更为复杂一些,会嵌套的层次更多,通过reactive可以最小化的简化异步回调地狱。

    // create a test table
    execute(conn.result(), "create table test(id int primary key, name varchar(255))", create -> {
      // start a transaction
      startTx(conn.result(), beginTrans -> {
        // insert some test data
        execute(conn.result(), "insert into test values(1, 'Hello')", insert -> {
          // commit data
          rollbackTx(conn.result(), rollbackTrans -> {
            // query some data
            query(conn.result(), "select count(*) from test", rs -> {
              for (JsonArray line : rs.getResults()) {
                System.out.println(line.encode());
              }
    
              // and close the connection
              conn.result().close(done -> {
                if (done.failed()) {
                  throw new RuntimeException(done.cause());
                }
              });
            });
          });
        });
      });
    });
    

    再看一个使用Reactive2构建的多步操作的代码,paramCheckStep,insertPayDtlStep,requestStep等等都是异步方法,但这里就很好的处理了异步回调的问题,不再有那么多层的大括号,代码结构也geng

    public void scanPay(JsonObject data, Handler<AsyncResult<JsonObject>> resultHandler) {
        paramCheckStep(data) // 参数校验
                .flatMap(this::insertPayDtlStep) // 插入流水
                .flatMap(x -> requestStep(x, config)) // 请求上游
                .flatMap(this::cleanStep) //参数清理
                .subscribe(ok -> {
                            logger.info("成功结束");
                            resultHandler.handle(Future.succeededFuture(ok));
                        },
                        err -> {
                            logger.error("正在结束", err);
                            resultHandler.handle(Future.failedFuture(err));
                        }
    
                );
    }

     (5)整合其他模块

    邮件客户端

    Vert.x提供了一简单STMP邮件客户端,所以你可以在应用程序中发送电子邮件。

    STOMP客户端与服务端

    Vert.x提供了STOMP协议的实现包括客户端与服务端。

    Consul Client

    consul是google开源的一个使用go语言开发的服务发现、配置管理中心服务。内置了服务注册与发现框 架、分布一致性协议实现、健康检查、Key/Value存储、多数据中心方案。

    RabbitMQ Client  Kafka Client

    消息队里的客户端支持

    JCA适配器

    Vert.x提供了Java连接器架构适配器,这允许同任意JavaEE应用服务器进行互操作。

    (6)认证与授权

    Vert.x提供了简单API用于在应用中提供认证和授权。

    Auth common 通用的认证API,可以通过重写AuthProvider类来实现自己的认证

    JDBC auth 后台为JDBC的认证实现

    JWT auth 用JSON Web tokens认证实现

    Shiro auth 使用Apache Shiro认证实现

    MongoDB auth MongoDB认证实现

    OAuth 2 Oauth2协义认证实现

    htdigest auth 这个是新增一种认证的支持

    (7)微服务

    Vert.x提供多个组件构建基于微服务的应用程序。

    比如服务发现(Vert.x Service Discovery)、断路器(Vert.x Circuit Breaker)、配置中心(Vert.x Config)等。

     

     

    Vert.x简明介绍就说到这里,最后,技术是为业务服务的,在选择架构的时候,也要考虑用人的成本,也正是因为如此,国内使用Vert.x的企业还不是很多。但是我相信,未来,一定是异步非阻塞的天下。

     

    关于Vert.x的简单介绍就到这里,后续文章会对Vert.x的api和他的实现原理进行说明,这里列几篇相关文章

    (一)Vert.x 简明介绍 https://blog.csdn.net/king_kgh/article/details/80772657

    (二)Vert.x创建简单的HTTP服务 https://blog.csdn.net/king_kgh/article/details/80804078

    (三)Vert.x Web开发之路由 https://blog.csdn.net/king_kgh/article/details/80848571

    (四)Vert.x TCP服务实现 https://blog.csdn.net/king_kgh/article/details/84870775

    (五)Vert.x数据库访问 https://blog.csdn.net/king_kgh/article/details/84894599

    (六)Vert.x认证和授权 https://blog.csdn.net/king_kgh/article/details/85218454

    (七)Vert.x事件总线(Event Bus)与远程服务调用 https://blog.csdn.net/king_kgh/article/details/86993812

    Vert.x 案例代码:https://github.com/happy-fly

     

    笔者就职于一家互联网支付公司,公司的核心项目使用的是Vert.x技术体系。记得笔者刚进入公司,接触Vert.x的时候,找遍了大大小小的网站,发现市面上关于Vert.x的文档除了官方文档外,几乎找不到其他资料。当时就励志要出一个专栏来写写Vert.x,以此帮助在Vert.x上采坑的朋友。因为笔者能力有限,文章中难免会有错误和疏漏,如果您对文章有意见或者好的建议,可以直接留言或者发送邮件到18366131816@163.com。如果您也对Vert.感兴趣,可以加入到我们,共同学习Vert.x,并推进国内开发者对Vert.x的认知。

    展开全文
  • vertx应用实战Vert.x Blueprint

    千次阅读 2018-05-21 19:02:32
    1.Vert.x 特性简介2.Vert.x Blueprint 实战3.Vert.x 未来展望4.Q&amp;A主题一、特性简介Vert.x能做什么?Polyglot Support•Java•Ruby•JavaScript•Groovy•Ceylon•Scala(in progress)开发模型/线程模型...

    1.Vert.x 特性简介
    2.Vert.x Blueprint 实战
    3.Vert.x 未来展望

    4.Q&A主题

    一、特性简介

    Vert.x能做什么?

    Polyglot Support

    •Java

    •Ruby

    •JavaScript

    •Groovy

    •Ceylon

    •Scala(in progress)

    开发模型/线程模型
    Verticle之间进行通信: Event Bus
    逻辑单元:Verticle(Actor-like)
    Event Loop线程:处理事件(不能阻塞!)

    Worker线程:可执行阻塞任务



    Verticle 线程安全



    异步开发模式


    异步开发模式


    Event Bus
    Vert.x的神经系统(各组件之间通信)
    •每个消息都会被发送至某个地址(address)
    •消息会在消息接收者绑定的Handler中进行处理

    •多种消息模式


    Event Bus Clients && Bridges
    •Go
    •C
    •C#
    •Python
    •SockJS(浏览器端/Node.js)
    •TCP
    •AMQP
    •Stomp

    •Camel

    Reactive Pattern

    Vert.x默认都是基于回调的API ——Nightmare!

    •Observable(Rx-fiedAPIs)

    •Vert.x Sync (Fiber)

    •Future(map/compose)

    二、Vert.x Blueprint 实战
    •2.1 Vert.x Web 开发简化
    •2.2 Event Bus 消息模式、原理及高阶应用
    •2.3 异步RPC
    •2.4 微服务设计与应用(服务发现、Circuit Breaker、API Gateway)
    •2.5 Vert.x Rx应用

    •2.6 整合其他框架

    Vert.x Blueprint

    •TodoBackend

    •Vert.x Kue

    •Micro-Shop Microservice

    http://vertx.io/blog/vert-x-blueprint-tutorials/

    Vert.x Web

    •REST Services/Web Application

    结合异步服务冗余代码多如何简化开发?

    •封装Helper Handler

    •封装Future-based Routing Handler

    •封装基于注解的Vert.x Web

    Vert.x Web原生代码


    Vert.x WebHelper Handler


    Vert.x Web另一种思路:类似于Play Framework 2


    Action: Request[A] => Result

    Vert.x Web


    Vert.x KueVert.x Kue


    是一个使用Vert.x开发的优先级工作队列,数据存储使用的是Redis。Vert.x Kue是Automattic/kue(Node.js)的Vert.x实现版本。


    再谈Event Bus

    •MessageProducer

    •Interceptor

    •MessageConsumer

    •Flow Control

    •集群模式实现原理

    •消息模型





    Event Bus 消息模型


    •Request/Response

    Clustered Event Bus实现原理

    •基于TCP

    •底层通过Cluster Manager同步ServerID

    •消息协议:一种简单的Wire Protocol



    Flow Control in Vert.x


    Event Bus 拦截器可以实现链式拦截


    拦截器本质是一个Handler<SendContext>我们可以通过message()方法获取包含的消息并进行处理,然后调用next()方法执行下一个拦截器(或进行消息的处理)

    VERTX异步RPC

    Asynchronous RPCVert.x 提供原生支持异步RPC的组件Vert.x Service Proxy



    自动生成:CheckoutServiceVertxEBProxy, CheckoutServiceVertxProxyHandler

    Vert.x Codegen

    Vert.x Codegen本质上是一个注解处理器(APT),编译时处理注解并根据模板生成相应的代码。

    .–生成JSON Converter

    .–生成其它语言的代码/Rx版本的代码

    .–生成服务代理类及服务代理处理器

    使用时需要在Maven/Gradle中进行相应的配置

    Asynchronous RPC 原理

    •底层通过Clustered Event Bus进行通信

    •通过Vert.x Codegen生成服务代理类



    VERT.X

    Microservice


    Microservice

    •Service Discovery (服务发现)

    •Circuit Breaker (断路器)

    •API Gateway

    •Event Sourcing (事件溯源模式)

    Micro-Shop 总览


    不同组件之间如何通信?

    •AsyncRPC (via Event Bus)

    •REST

    •Message (via Event Bus)

    •自定义


    Service Discovery(Registry)

    •用服务记录(Record)代表某一个服务,里面保存着服务的名称、类型、位置以及其它元数据

    •创建好服务记录后即可发布服务(publish)

    •需要调用服务时,可以从服务发现组件获取服务记录,然后创建对应的服务实例

    •可以自定义ServiceImporter导入服务,或ServiceExporter导出服务

    服务记录存储在哪里?

    不同的ServiceDiscoveryBackend代表不同的存储机制

    •默认存储在LocalMap(单机模式)/DistributedMap(集群模式,具体取决于Cluster Manager)

    •Vert.x也提供RedisBackend ——将服务记录存储于Redis中

    •ZooKeeperBackend (3.4.0特性)

    Circuit Breaker


    Event Sourcing

    [(A123456, 4),(A1763515, 1)]


    Event Sourcing的优点DDD/CQRS/Event Sourcing

    •我们可以从过去的事件序列中组建出任意时刻的数据状态

    •每个过去的事件都得以保存,因此这使得补偿事务成为可能

    •我们可以从事件存储中获取事件流,并且以异步、响应式风格对其进行变换和处理

    •事件存储同样可以当作为数据日志

    API Gateway


    API Gateway

    •针对Failure设计,实现容错

    •请求的分发,协议的转换

    •重要组件,需要保证高可用(HA)

    •权限管理

    •心跳检测

    •性能?

    API Gateway分发请求(Reverse Proxy)

    .Prepare: 每个REST Endpoint在发布的时候都会在元数据内存储对应的api.name

    .请求格式:/api/{api.name}/xxx

    .过程:首先解析请求路径对应的api.name,然后从服务发现层获取此API对应的所有REST服务记录列表;接着根据一定的负载均衡算法从其中选出一个服务记录,构造服务实例,然后进行请求的转发。

    API Gateway

    分发请求(Reverse Proxy)


    API Gateway请求分发的另外一些情况

    •HTTP(S) -> Event Bus:使用request/response消息模型与服务进行通信

    •缺陷:Event Bus需要支持地址匹配(类似于路由,目前已列入wishlist)

    •HTTP(S) -> 其他协议:实现协议转换接口(比如实现对应的Event Bus Bridge)

    API Gateway

    结合Circuit Breaker


    VerticleFailover

    HA模式下,Verticle挂了以后会在集群内的其他节点redeploy



    Vert.x Auth(JDBC/JWT/Mongo/Shiro/OAuth2)

    •如何与API Gateway结合?

    •如何简化权限验证的逻辑?

    权限管理

    •得到Principal以后,将其通过Header传递至下层服务中


    •封装一个requireLogin路由处理包装来简化权限验证


    •若传入的principal不合法或不存在,直接返回401

    •相应的路由处理函数里面可以获取Principal:


    Rx-fiedAPIs in Vert.x


    Vert.x Rx API 返回的Observable本质上是一种Single(Emit once)与Future类似Rx-fiedAPIs in Vert.x

    Rx-fiedAPIs in Vert.x

    •getConnectionObservable(): Observable<SQLConnection>

     •getConnection(handler): voidReactive!


    如何与其它框架/库整合?

    .异步API:Context#runOnContextExample:Netflix Hystrix(Async)IMPORTANT: 要遵循Vert.x的线程模型!

    .同步API:Vertx#executeBlockingExample :MyBatisORM

    三、未来展望

    New Components

    •Vert.x Kafka Client (Stream based)

    •Vert.x ZooKeeperCluster

    •Vert.x Consul Client

    •Vert.x ScalaAnd maybe many more…

    •Vert.x Configuration Service

    点击打开链接


    展开全文
  • Vert.x(vertx)入门资料

    千次阅读 2019-08-02 14:40:46
    1.vert.x简介 vert.x 采用类似 Node.js 的 eventloop callback 机制,优势是 Eventloop 是单线程场景下几乎是最快的并发解决方案,但也需要周边生态的支持,比如 DbClient/HttpClient 这些跟 IO 打交道的 API 需要...
  • Vert.x学习笔记(一) Vert.x 核心包

    千次阅读 2017-08-02 01:15:43
    Vert.x是一个事件驱动的JVM上的框架,可以帮助我们构建现代、灵活、可扩展的程序。Vert.x有多种语言的版本,可以用在Java、Kotlin、Scala、Groovy、Ruby等语言上。当然现在讨论的是如何在Java上使用Vert.xVert.x是...
  • 常数向量的内积与范数  两个m×1m×1的向量之间的内积(点积)定义为: ⟨x,y⟩=xHy=∑i=1mx∗...cosθ=⟨x,y⟩⟨x,x⟩⟨y,y⟩−−−−−−−−−√=xHy∥x∥∥y∥cos \theta = \frac{\langle x,y\rangle}{\sqrt {\
  • Vert.x入门教程之Hello World

    万次阅读 2016-06-12 18:27:39
    开发掌上洪城App,后台用到Vert.x,以前没用过,看官方文档(http://vertx.io/docs/)从零开始学习,博客记录学习所得,期望有更多交流: 代码运行后,浏览器输入:http://localhost:8080/hello 查看效果 相关包可在...
  • 得益于Spring Boot的便捷性,使用JAVA语言开发REST服务变成了一件非常简单的工作,但于此同时我们也不得不面对一个问题,目前Spring MVC+Spring ...Spring Boot为此推出了2.X版本,其基于 Spring 5 Framework ,提...
  • Vert.x中文文档

    千次阅读 2018-11-26 17:04:24
    https://vertxchina.github.io/vertx-translation-chinese/
  • Vert.x 与Springboot集成

    万次阅读 2018-12-02 23:17:40
    Vert.x利用Netty4的EventLoop来做单线程的事件循环,所以跑在Vert.x上的业务不能做CPU密集型的运算,这样会导致整个线程被阻塞。 Springboot是应用非常广泛的java快速开发框架,它提供了与数据库,w...
  • Vert.x开发指南

    万次阅读 2013-05-20 11:27:01
    Vert.x开发指南作者:chszs,转载需注明。博客主页:http://blog.csdn.net/chszs一、介绍Vert.x是一个异步应用程序开发框架,可用于开发异步、可伸缩、高并发的Web应用。其目的在于为JVM提供一个Node.js的替代方案。...
  • Akka和VertX比较

    千次阅读 2014-09-21 10:50:00
    Akka和VertX都是scala写大数据框架的极其赞的technology Akka是用来写高concurrent,distributed,和fault tolerant event-driven的一个工具箱/库 而vertx是一个具有类似功能的framework ...
  • Vert.x ——概述

    千次阅读 2016-12-21 15:07:42
    Vert.x是什么 Vert.x(http://vertx.io/)是一个基于JVM、轻量级、高性能的应用平台,非常适用于最新的移动端后台、互联网、企业应用架构。 Vert.x框架基于事件和异步,依托于全异步Java服务器Netty,并扩展了很多...
  • Vert.x与Netty的区别

    千次阅读 2019-06-18 15:08:31
    虽然Vert.x是基于Netty的更高级封装,但它们解决的问题是不太一样的。可以认为Vert.x是Netty的超集,它利用Netty的Eventloop为开发者提供了更友好的编程模型。 Netty解决了如何支撑大量连接的问题 Netty作为一个网络...
  • vert.x入门

    千次阅读 2015-09-26 23:28:32
    Vert.x是一个事件驱动、非阻塞的异步编程框架,随着互联网应用越来越追求响应速度和高并发处理能力,异步编程将成为未来编程的主流。vert.x由于支持多种语言,性能良好,在国外受到很好的开发者支持。本教程将对vert...
  • Vertx简介

    万次阅读 2016-06-24 17:54:44
    今天看了一篇很不错的关于Vertx的简介,转载下。  原文链接:...   ...Vert.x的由来 ...Vert.x诞生于2011年,当时叫node.x,不过后来因为某些原因改名位Vert.
  • Undertow、Vert.x 和 Netty 的压力测试比较 Tech Empower 对 90 个框架进行了性能方面的比较测试,这些测试主要是设计一些基础的任务,例如 JSON 序列化、数据库访问、服务端模板生成等等。你可以从in
  • [Unity3D]UGUI 新手引导遮罩控件

    千次阅读 2017-06-05 19:32:17
    [Unity3D]UGUI 新手引导遮罩控件强制性引导UI控件,关键区域镂空,自动调整关键区域大小。 * 效果如图: * 使用结构: 代码块示例代码:using UnityEngine; using System.Collections; using UnityEngine.UI;...
  • 使用IDEA 创建一个vert.x 项目

    千次阅读 2018-03-05 10:20:12
    使用IDEA 创建一个vert.x 项目这里我使用的Gredle2 选择Gredle3 修改build文件,添加vert.x 相关的资源4 开始写代码了 package com.xllyll.demo.vertx; import io.vertx.core.Vertx; public class APP { public ...
1 2 3 4 5 ... 20
收藏数 15,212
精华内容 6,084
热门标签
关键字:

vert.x