Vertx集群部署实例
Vertx集群部署，官方介绍了几种方式，其中有一种方式是使用HazelCast来实现的，下面介绍如何通过HazelCast
来实现Vertx集群部署。
HazelCast默认采用UDP广播的方式实现节点之间的互通，从而实现内部信息共享达到集群目的，前提是节点都在
同一个网段，而且节点如果有多个网卡，节点启动时，还得指定相应的网卡(cluster-host)作为集群之间通信的IP，
网络要求较高。也可以采用TCPIP的方式，通过配置cluster.xml，将节点IP加入tcp-ip节点的interface节点，节点启动
之后会通过指定IP使节点之间通过socket连接构建集群，通过这种方式构建集群，就需要改动hazelcast集群
配置文件cluster.xml。
项目介绍：
该工程实现这样的功能：通过vertx构建一个HttpServer,并且监听8082端口，接收前端的业务需求，最后通过判断，
如果请求(http://hostname:8082/pushservice/2.0/poll)中带有参数type,就利用vertx的EventBus事件机制向注册
pushservice-poll的Verticle发送一个消息，而注册pushservice-poll的Verticle接收到消息之后，会向mongo数据库
中插入一条记录，这样整个的请求就算完成。这里面利用了vertx-web的路由功能，接收指定path(/pushservice
/2.0/poll)请求，还利用了vertx-core的EventBus，实现Verticle之间互相通信。
工程目录结构：
第一步、构建maven项目，配置vertx-web和hazelcast相关依赖；
com.lenovo.push.start.ClusterStarter junit junit 4.12 test io.vertx vertx-unit 3.3.3 test io.vertx vertx-web 3.3.3 io.vertx vertx-mongo-client 3.3.3 io.vertx vertx-mongo-embedded-db 3.3.3 io.vertx vertx-hazelcast 3.3.3 io.netty netty-all 4.1.7.Final com.fasterxml.jackson.core jackson-databind 2.8.6 org.apache.logging.log4j log4j-api 2.7 org.apache.logging.log4j log4j-core 2.7 maven-compiler-plugin 3.3 1.8 1.8 org.apache.maven.plugins maven-jar-plugin 2.5 /*.properties /*.xml false ${mainClass} com.google.code.maven-replacer-plugin replacer 1.5.3 prepare-package replace assemblise/bin/app.sh #MAIN_CLASS# ${mainClass} target/bin/app.sh org.apache.maven.plugins maven-assembly-plugin 2.4 assembly.xml make-assembly package single
这里面还配置了一个利用Assembly插件打包的工具，日志采用log4j2，引入了vertx-mongo，后面会用来向mongo
数据库中插入数据。
第二步、书写业务代码，实现项目的功能；
配置文件vertx.properties(数据库连接属性和集群配置本例子没有使用集群配置，只是简单的设置了cluster为true)
#VertxOptions vertx.active=VXWEB vertx.VXWEB.pool.size.event.loop=64 vertx.VXWEB.pool.size.worker=256 vertx.VXWEB.pool.size.internal.blocking=256 vertx.VXWEB.cluster.enabled=true vertx.VXWEB.cluster.host=localhost vertx.VXWEB.cluster.port=3000 vertx.VXWEB.cluster.ping.interval=1000 vertx.VXWEB.cluster.ping.interval.reply=1000 vertx.VXWEB.blocked.thread.check.interval=1000 vertx.VXWEB.execute.time.max.event.loop=60000000000 vertx.VXWEB.execute.time.max.worker=60000000000 vertx.VXWEB.ha.enabled=true vertx.VXWEB.ha.group=__DEFAULT__ vertx.VXWEB.quorum.size=1 vertx.VXWEB.warning.exception.time=5000000000 #DeploymentOptions http.port=8082 db_name=pushservice connection_string=mongodb://192.168.56.201:27017
ResourceLoader.java(读取配置文件工具类)
package com.lenovo.push.loader;
import java.io.File;
import java.io.FileInputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
public class ResourceLoader {
private static ResourceLoader loader = new ResourceLoader();
private static Map loadermap = new HashMap();
private static String DEFAULT_CONFIG_FILE="vertx.properties";
private ResourceLoader(){}
public static ResourceLoader getInstance(){
return loader;
}
public Properties getPropFromProperties(String fileName) throws Exception{
Properties prop = loadermap.get(fileName);
if(prop!=null)return prop;
String path = getClass().getClassLoader().getResource(fileName).getPath();
prop = new Properties();
prop.load(new FileInputStream(new File(path)));
loadermap.put(fileName, prop);
return prop;
}
public String getString(String key) throws Exception{
Properties prop = ResourceLoader.getInstance().getPropFromProperties(DEFAULT_CONFIG_FILE);
String value = prop.getProperty(key);
return value;
}
public Integer getInt(String key) throws Exception{
return Integer.parseInt(getString(key));
}
public Long getLong(String key) throws NumberFormatException, Exception{
return Long.parseLong(getString(key));
}
public Boolean getBoolean(String key) throws Exception{
return Boolean.parseBoolean(getString(key));
}
public static void main(String[] args) throws Exception{
System.out.println(loader.getString("vertx.VXWEB.cluster.enabled"));
}
}
OptionsReader.java(获取集群和部署配置类属性)
package com.lenovo.push.deploy;
import io.vertx.core.DeploymentOptions;
import io.vertx.core.VertxOptions;
import io.vertx.core.json.JsonObject;
import com.lenovo.push.loader.ResourceLoader;
public class OptionsReader {
private static final String VX_PREFIX = "vertx.";
private static ResourceLoader LOADER = ResourceLoader.getInstance();
public static VertxOptions readOpts(final String name) throws Exception{
final VertxOptions options = new VertxOptions();
options.setEventLoopPoolSize(LOADER.getInt(VX_PREFIX+name+".pool.size.event.loop"));
options.setWorkerPoolSize(LOADER.getInt(VX_PREFIX+name+".pool.size.worker"));
options.setInternalBlockingPoolSize(LOADER.getInt(VX_PREFIX+name+".pool.size.internal.blocking"));
options.setClustered(LOADER.getBoolean(VX_PREFIX+name+".cluster.enabled"));
options.setClusterHost(LOADER.getString(VX_PREFIX+name+".cluster.host"));
options.setClusterPort(LOADER.getInt(VX_PREFIX+name+".cluster.port"));
options.setClusterPingInterval(LOADER.getLong(VX_PREFIX+name+".cluster.ping.interval"));
options.setClusterPingReplyInterval(LOADER.getLong(VX_PREFIX+name+".cluster.ping.interval.reply"));
options.setBlockedThreadCheckInterval(LOADER.getLong(VX_PREFIX+name+".blocked.thread.check.interval"));
options.setMaxEventLoopExecuteTime(LOADER.getLong(VX_PREFIX+name+".execute.time.max.event.loop"));
options.setMaxWorkerExecuteTime(LOADER.getLong(VX_PREFIX+name+".execute.time.max.worker"));
options.setHAEnabled(LOADER.getBoolean(VX_PREFIX+name+".ha.enabled"));
options.setHAGroup(LOADER.getString(VX_PREFIX+name+".ha.group"));
options.setQuorumSize(LOADER.getInt(VX_PREFIX+name+".quorum.size"));
options.setWarningExceptionTime(LOADER.getLong(VX_PREFIX+name+".warning.exception.time"));
return options;
}
public static DeploymentOptions readOpts() throws Exception{
final DeploymentOptions options = new DeploymentOptions();
options.setConfig(new JsonObject()
.put("http.port", LOADER.getInt("http.port"))
.put("db_name", LOADER.getString("db_name"))
.put("connection_string", LOADER.getString("connection_string")));
return options;
}
}
RootVerticle.java(设置监听，请求路由，接收请求然后发送消息到PollVerticle)
package com.lenovo.push.verticle;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.Future;
import io.vertx.core.eventbus.EventBus;
import io.vertx.core.http.HttpServer;
import io.vertx.core.http.HttpServerResponse;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.web.Router;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class RootVerticle extends AbstractVerticle {
public static final Logger log = LogManager.getLogger(RootVerticle.class);
public void start(Future future){
final HttpServer server = vertx.createHttpServer();
Router router = Router.router(vertx);
router.route("/").handler(routingContext -> {
HttpServerResponse response = routingContext.response();
response.putHeader("content-type", "text/html");
response.end("Hello from vertx cluster.
");
});
//接收上报消息
router.routeWithRegex("/pushservice/*.*/poll*").handler(routingContext -> {
HttpServerResponse response = routingContext.response();
boolean hastype = routingContext.request().params().contains("type");
if(hastype){
//使用eventbus发送消息
EventBus eb = vertx.eventBus();
eb.publish("pushservice-poll", "datareport");
}else{
//
}
response.putHeader("content-type", "application/json");
response.end(new JsonObject().put("code", 200).put("status", "ok").toString());
});
router.routeWithRegex("/pushservice/*.*/appfeedback*").handler(routingContext -> {
HttpServerResponse response = routingContext.response();
String lpsst = routingContext.request().getParam("lpsst");
System.out.println("lpsst get: " + lpsst);
String body = routingContext.getBodyAsString();
System.out.println(body);
response.putHeader("content-type", "text/html");
response.end("feedback ok!
");
});
router.routeWithRegex("/pushservice/*.*/appinfo*").handler(routingContext -> {
HttpServerResponse response = routingContext.response();
response.putHeader("content-type", "text/html");
response.end("appinfo ok!
");
});
server.requestHandler(router::accept);
server.listen(config().getInteger("http.port", 8080),result -> {
if(result.succeeded()){
future.complete();
}else{
future.fail(result.cause());
}
});
log.info("httpserver listenning on port : "+config().getInteger("http.port",8080));
}
}
PollVerticle.java(接收消息然后向mongo中写入一条记录)
package com.lenovo.push.verticle;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.eventbus.EventBus;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.mongo.MongoClient;
public class PollVerticle extends AbstractVerticle {
public static final Logger log = LogManager.getLogger(PollVerticle.class);
public static int count = 1;
@Override
public void start() throws Exception {
//final MongoClient mongo = MongoClient.createShared(vertx, new JsonObject().put("db_name", "lenovodb").put("connection_string", "mongodb://192.168.56.201:27017"));
final MongoClient mongo = MongoClient.createShared(vertx, config());
EventBus eb = vertx.eventBus();
eb.consumer("pushservice-poll",message ->{
String msg = (String)message.body();
log.info("received message: "+msg);
JsonObject user = new JsonObject().put("id", count)
.put("name", "vertx"+(count++))
.put("age", "333")
.put("mobile", "no");
//插入用户信息
mongo.insert("users", user,lookup->{
if(lookup.failed()){
log.error("insert user error: "+lookup.cause());
return;
}
});
});
}
}
ClusterStarter.java(部署Verticle，启动集群类
package com.lenovo.push.start;
import io.vertx.core.DeploymentOptions;
import io.vertx.core.Vertx;
import io.vertx.core.VertxOptions;
import java.util.function.Consumer;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import com.lenovo.push.deploy.OptionsReader;
public class ClusterStarter {
private static final Logger log = LogManager
.getLogger(ClusterStarter.class);
public static void main(String[] args) throws Exception {
/*
* final VertxOptions options = OptionsReader.readOpts("VXWEB"); final
* VertxFactory factory = new VertxFactoryImpl(); final ClusterManager
* manager = new HazelcastClusterManager(new Config());
* options.setClusterManager(manager); factory.clusteredVertx(options,
* res -> { if(res.succeeded()){ final Vertx vertx = res.result(); final
* DeploymentOptions opts = OptionsReader.readOpts();
* vertx.deployVerticle("com.lenovo.verticle.RouterVerticle", opts);
* vertx.deployVerticle("com.lenovo.verticle.PollVerticle", opts);
* log.info("Deploye RouterVerticle with cluster ok!"); } });
*/
final VertxOptions options = new VertxOptions();
options.setClustered(true);
final DeploymentOptions opts = OptionsReader.readOpts();
Consumer runner = vertx -> {
vertx.deployVerticle("com.lenovo.push.verticle.RootVerticle",opts);
vertx.deployVerticle("com.lenovo.push.verticle.PollVerticle",opts);
};
if (options.isClustered()) {
Vertx.clusteredVertx(
options,
result -> {
if (result.succeeded()) {
Vertx vertx = result.result();
runner.accept(vertx);
log.info("pushservice is running with cluster by hazelcast.");
} else {
log.error("cluster running with error: "
+ result.cause().getMessage());
}
});
} else {
Vertx vertx = Vertx.vertx(options);
runner.accept(vertx);
}
}
}
第三步、打包部署并检验集群。
本实例通过Assembly插件打包。打包之后生成如下的文件。
我自己的两台虚拟机都只有一个网卡，而且都在同一网段，所以可以使用默认的广播方式构建集群，因此也不需要
配置文件cluster.xml。
启动之后查看日志，机器IP分别是:192.168.56.201和192.168.56.202
192.168.56.201上的启动日志，注意标识红色框的位置区别：
192.168.56.202上的启动日志：
集群确实构建成功，现在可以测试工程的功能，发送一个请求http://192.168.56.201:8082/pushservice/2.0/poll?
type=2，查看返回结果。
