Java 在Eclipse中停止vertx垂直

我正在关注vertx。这里我有两个文件：

MyVerticle.java：

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Future;

public class MyVerticle extends AbstractVerticle {

    @Override
    public void start(Future<Void> startFuture) {
        System.out.println("MyVerticle started!");
    }

    @Override
    public void stop(Future stopFuture) throws Exception {
        System.out.println("MyVerticle stopped!");
    }
}

运行

VertxVerticleMain.java

之后，我在Eclipse的控制台中看到了

“MyVerticle已启动！”

，但不知道如何在

MyVerticle

中调用

stop

Jenkov说，当Vert.x关闭并且verticle需要停止时，会调用stop（）方法。我该如何关闭Vert.x并停止垂直？我想看到MyVerticle停止。

来自：

如果从主方法运行Vert.x并终止JVM进程（例如，通过在Eclipse中单击“停止”按钮），Vert.x可能不会发出取消部署垂直链接的信号，或者JVM在Vert.x有时间取消部署垂直链接之前终止

您可以做很多事情来确保verticle将被取消部署并调用stop（）方法：

使用vertx命令行启动垂直。当您停止进程（或告诉vert.x停止）时，vert.x将确保所有垂直通道都已取消部署

通过获取deploymentId列表并调用undeploy for all id，您可以通过编程方式取消部署已部署的垂直站点：

vertx.deploymentIDs().forEach(vertx::undeploy);

您可以通过编程方式告诉Vert.x停止：

vertx.close();

您可以添加一个关机挂钩，以确保在JVM终止时执行上述选项之一：

Runtime.getRuntime().addShutdownHook(new Thread() {
    public void run() {
        vertx.close();
    }
});

您可以通过调用Vert.xapi以编程方式取消部署verticle，也可以停止Java进程，这会触发Vert.x进程停止

---

顺便说一句，你应该问问自己，运行verticle的进程停止时是否真的需要始终调用stop（）方法。你永远无法确定那会发生；当进程被迫停止或终止时，可能不会调用stop（）方法。

您的代码应该添加super.stop（）和super.start（）函数，如下所示：

public class MyVerticle extends AbstractVerticle {

    @Override
    public void start(Future<Void> startFuture) {
        //must call super.start() or call startFuture.complete()
        super.start(startFuture); 
        System.out.println("MyVerticle started!");
        System.out.println("Verticle_stopFuture.start(): deployId=" + context.deploymentID());
    }

    @Override
    public void stop(Future stopFuture) throws Exception {
        //must call super.stop() or call stopFuture.complete()
        super.stop(stopFuture);
        System.out.println("MyVerticle stopped!");
    }
}

公共类MyVerticle扩展了AbstractVerticle{
@凌驾
公共作废开始（未来开始未来）{
//必须调用super.start（）或调用startFuture.complete（）
超级启动（开始未来）；
System.out.println（“MyVerticle启动了！”）；
System.out.println（“Verticle_stopFuture.start（）：deployId=“+context.deploymentID（））；
}
@凌驾
公共void stop（Future stopFuture）引发异常{
//必须调用super.stop（）或调用stopFuture.complete（）
超级。停止（停止未来）；
System.out.println（“MyVerticle停止！”）；
}
}

和VertxVerticleMain.java：

import io.vertx.core.Vertx;

public class VertxVerticleMain {

    public static void main(String[] args) {
        Vertx vertx = Vertx.vertx();

        vertx.deployVerticle(new MyVerticle());
    }
}

public class VertxVerticleMain {
    static String verticle_deployId;

    public static void main(String[] args) throws InterruptedException {
        System.out.println("start main(): thread="+Thread.currentThread().getId());


        Vertx vertx = Vertx.vertx();

        vertx.deployVerticle(new MyVerticle(), new Handler<AsyncResult<String>>(){

            @Override
            public void handle(AsyncResult<String> asyncResult) {

                if (asyncResult.succeeded()) { // khi startFuture.complete() đc gọi
                    System.out.println("asyncResult = DeployId =" + asyncResult.result());

                    verticle_deployId = asyncResult.result();
                } else { //khi startFuture.fail() đc gọi
                    System.out.println("Deployment failed!");  //vì chưa đc cấp id
                }
            }
        });

        // waiting for Verticle context is allocate by Vertx
        Thread.currentThread().sleep(500);

        Set<String> deploymentIDs = vertx.deploymentIDs();
        System.out.println("==============  (sleeped 500ms wait for Context allocated), list of deploymentIDs: number Deployments =" + deploymentIDs.size());
        for(String depId: deploymentIDs){
            //
            System.out.println(depId);
        }

        //close verticle here
        vertx.undeploy(verticle_deployId);


    }

}

公共类VertxVerticleMain{
静态字符串垂直部署ID；
公共静态void main（字符串[]args）引发InterruptedException{
System.out.println（“start main（）：thread=“+thread.currentThread（）.getId（））；
Vertx Vertx=Vertx.Vertx（）；
deployVerticle（新的MyVerticle（），新的处理程序（）{
@凌驾
公共无效句柄（AsyncResult AsyncResult）{
if（asyncResult.succeed（））{//khi startFuture.complete（）đc gọ我
System.out.println（“asyncResult=DeployId=“+asyncResult.result（））；
verticle_deployId=asyncResult.result（）；
}else{//khi startFuture.fail（）đc gọ我
System.out.println（“部署失败！”；//vìchưađcấp id
}
}
});
//等待垂直上下文由Vertx分配
Thread.currentThread（）.sleep（500）；
设置deploymentIDs=vertx.deploymentIDs（）；
System.out.println（“===================（休眠500毫秒等待上下文分配），DeploymentId列表：number Deployments=“+DeploymentId.size（））；
for（字符串depId:DeploymentId）{
//
系统输出打印项次（部门ID）；
}
//在这里关闭垂直线
垂直解除部署（垂直部署ID）；
}
}

我有一种预感，

stop

被称为关机挂钩的一部分。当您在eclipse中终止控制台会话时（通过单击右上角的红方块），会发生什么情况？@jornverne：我试过了，但什么也没发生。光标停留在原来的位置，没有打印其他内容。您签出文档（）了吗

Vertx

有一个名为

close

的方法可能会起作用。我在

deployVerticle

之后添加了

Vertx.close（）

，但仍然看不到

stop

的输出。控制台确实通知进程已终止。部署verticles是一个异步进程。因此，如果在deployVerticle之后立即调用vertx.close（），Vert.x只是刚刚开始部署verticle。当您调用vertx.close（）时，它可能还没有部署，这就是为什么它不会在vertx.close（）上取消部署。因此，在调用vertx.close（）之前，请在deployVerticle之后稍等片刻，或者在部署完成时使用带有回调的deployVerticle方法来部署verticle:

vertx.deployVerticle（verticle，deployed->{//部署后调用

}）；或者使用上面提到的关机钩子；deployVerticle（new Verticle1（），deployed->{System.out.println（“verticle启动后的回调”）；vertx.close（）；}）；如果你想做这样的事情，那是行不通的。第一点：我们如何告诉Vert.x停止？我们需要调用哪个方法？我们如何指示Vert.x httpserver正常停止？您可以通过停止Vert.x进程来告诉Vert.x停止。停止容器或向Vert.x进程发送

kill

命令。注意：如果您发送一个SIGKILL，进程将被终止。如果发送SIGTERM（kill的默认信号），Vert.x将尝试正常关闭，包括正常停止Vert.x httpserver。我认为您无法以编程方式停止Vert.x实例。您可以停止JVM程序Matica

public class VertxVerticleMain {
    static String verticle_deployId;

    public static void main(String[] args) throws InterruptedException {
        System.out.println("start main(): thread="+Thread.currentThread().getId());


        Vertx vertx = Vertx.vertx();

        vertx.deployVerticle(new MyVerticle(), new Handler<AsyncResult<String>>(){

            @Override
            public void handle(AsyncResult<String> asyncResult) {

                if (asyncResult.succeeded()) { // khi startFuture.complete() đc gọi
                    System.out.println("asyncResult = DeployId =" + asyncResult.result());

                    verticle_deployId = asyncResult.result();
                } else { //khi startFuture.fail() đc gọi
                    System.out.println("Deployment failed!");  //vì chưa đc cấp id
                }
            }
        });

        // waiting for Verticle context is allocate by Vertx
        Thread.currentThread().sleep(500);

        Set<String> deploymentIDs = vertx.deploymentIDs();
        System.out.println("==============  (sleeped 500ms wait for Context allocated), list of deploymentIDs: number Deployments =" + deploymentIDs.size());
        for(String depId: deploymentIDs){
            //
            System.out.println(depId);
        }

        //close verticle here
        vertx.undeploy(verticle_deployId);


    }

}