Java 在verticle vert.x中实例化类的危险

我解释了我的问题，我有一个竖线，我定义了所有的路线。我有一些简单的java类，这些类包含我在垂直路径中根据路径调用的方法。例如，my downloadFile（）方法位于MyFile类中，如下所示：

    public class MyFile {

        public final void downloadFile(RoutingContext rc, Vertx vertx) {
            final HttpServerResponse response = rc.response();
            response.putHeader("Content-Type", "text/html");
            response.setChunked(true);

            rc.fileUploads().forEach(file -> {

                final String fileNameWithoutExtension = file.uploadedFileName();

                final JsonObject jsonObjectWithFileName = new JsonObject();
                 response.setStatusCode(200); 
                 response.end(jsonObjectWithFileName.put("fileName", fileNameWithoutExtension).encodePrettily());
            });
        }

       public final void saveFile(RoutingContext rc, Vertx vertx) {
                 //TODO
       }
    }

    public class MyVerticle extends AbstractVerticle{

            private static final MyFile myFile = new MyFile();

            @Override
            public void start(Future<Void> startFuture) {
                final Router router = Router.router(vertx);
                final EventBus eventBus = vertx.eventBus();

                router.route("/getFile").handler(routingContext -> {
                    myFile.downloadFile(routingContext, vertx);
                });

        router.route("/saveFile").handler(routingContext -> {
                    myFile.saveFile(routingContext, vertx);
                });
            }
    }

我在我的垂直中使用这个类，如下所示：

    public class MyFile {

        public final void downloadFile(RoutingContext rc, Vertx vertx) {
            final HttpServerResponse response = rc.response();
            response.putHeader("Content-Type", "text/html");
            response.setChunked(true);

            rc.fileUploads().forEach(file -> {

                final String fileNameWithoutExtension = file.uploadedFileName();

                final JsonObject jsonObjectWithFileName = new JsonObject();
                 response.setStatusCode(200); 
                 response.end(jsonObjectWithFileName.put("fileName", fileNameWithoutExtension).encodePrettily());
            });
        }

       public final void saveFile(RoutingContext rc, Vertx vertx) {
                 //TODO
       }
    }

    public class MyVerticle extends AbstractVerticle{

            private static final MyFile myFile = new MyFile();

            @Override
            public void start(Future<Void> startFuture) {
                final Router router = Router.router(vertx);
                final EventBus eventBus = vertx.eventBus();

                router.route("/getFile").handler(routingContext -> {
                    myFile.downloadFile(routingContext, vertx);
                });

        router.route("/saveFile").handler(routingContext -> {
                    myFile.saveFile(routingContext, vertx);
                });
            }
    }

公共类MyVerticle扩展了AbstractVerticle{
私有静态最终MyFile MyFile=新MyFile（）；
@凌驾
公共作废开始（未来开始未来）{
最终路由器=路由器.路由器（vertx）；
final EventBus EventBus=vertx.EventBus（）；
router.route（“/getFile”）.handler（routingContext->{
下载文件（routingContext，vertx）；
});
router.route（“/saveFile”）.handler（routingContext->{
saveFile（routingContext，vertx）；
});
}
}

我的同事告诉我，用竖线实例化一个类是不好的，当我问他为什么时，他回答说它变成有状态的，我怀疑他对我说的话，因为我不知道怎么说。当我在我的verticle中声明我的MyFile类实例为“static final”时，我想说我甚至可以提高性能，因为我对每个传入的请求使用相同的实例，而不是创建新的实例

如果在垂直体中实例化一个类是不好的，请解释为什么

此外，我想知道使用两个眩晕进行一种只有一个眩晕可以做的治疗有什么好处

例如，我想用我在数据库中选择的数据构建一个JsonObject，为什么要将此数据发送到另一个verticle，而知道此verticle除了构建JsonObject之外什么都不做，然后等待它回答我是否已将响应发送到客户端，这样我就可以在我发出请求的verticle中构建此JsonObject，并立即将响应发送到客户端。我为您提供了一个伪代码，以便更好地查看：

public class MyVerticle1 extends AbstractVerticle{

    public void start(Future<Void> startFuture) {

        connection.query("select * from file", result -> {

            if (result.succeeded()) {
                List<JsonArray> rowsSelected = result.result().getResults();
                eventBus.send("adress", rowsSelected, res -> {
                    if (res.succeded()) {
                        routinContext.response().end(res.result().encodePrettily());
                    }
                });
            } else {
                LOGGER.error(result.cause().toString());
            }

        });

    }

}

public class MyVerticle2 extends AbstractVerticle{

    public void start(Future<Void> startFuture) {
        JsonArray resultOfSelect = new JsonArray();

        eventBus.consumer("adress", message -> {
            List<JsonArray> rowsSelected = (List<JsonArray>) message.body();
            rowsSelected.forEach(jsa -> {
                JsonObject row = new JsonObject();
                row.put("id", jsa.getInteger(0));
                row.put("name", jsa.getString(1));
                resultOfSelect.add(row);
            });

            message.reply(resultOfSelect);
        });
    }
}

公共类MyVerticle1扩展了AbstractVerticle{
公共作废开始（未来开始未来）{
connection.query（“从文件中选择*”，结果->{
if（result.successed（））{
列表行selected=result.result（）.getResults（）；
eventBus.send（“地址”，已选择行，res->{
如果（res.succeed（））{
routinext.response（）.end（res.result（）.encodeprettiliy（））；
}
});
}否则{
LOGGER.error（result.cause（）.toString（））；
}
});
}
}
公共类MyVerticle2扩展了AbstractVerticle{
公共作废开始（未来开始未来）{
JsonArray resultOfSelect=新的JsonArray（）；
eventBus.consumer（“地址”，消息->{
List rowsSelected=（List）message.body（）；
行选择。forEach（jsa->{
JsonObject行=新的JsonObject（）；
row.put（“id”，jsa.getInteger（0））；
row.put（“name”，jsa.getString（1））；
resultOfSelect.add（行）；
});
message.reply（resultOfSelect）；
});
}
}

我真的看不出制作两个垂直轴的意义，因为我可以在第一个垂直轴中使用查询结果，而不使用第二个垂直轴

---

对我来说，EventBus对于将信息传输到Verticle进行并行处理非常重要。

请记住。。。不幸的是，您正在寻找的答案非常微妙，并且会根据一些条件（例如，回答者的经验、代码库中的设计习惯、您可以使用的工具/库等）而有所不同。因此，没有权威的答案，只有适合你（和你的同事）的答案

我的同事告诉我，在一个类中实例化一个类是不好的 当我问他为什么时，他回答说它变得有状态了 我怀疑他对我说的话，因为我不知道怎么说

您的同事在一般意义上是正确的，您不希望集群中的单个节点保持自己的状态，因为这实际上会妨碍可靠扩展的能力。但在这种特殊情况下，

MyFile

似乎是无状态的，因此将其作为垂直体的成员引入不会自动使服务器有状态

（如果有什么问题的话，我会反对

MyFile

做的不仅仅是基于文件的操作，它还处理HTTP请求和响应）

正如我在 verticle，我想说我甚至在性能上有所提高，因为我使用了 为每个传入请求创建相同的实例，而不是创建新的 例如

我认为这是设计偏好。就其本身而言，这里没有任何真正的“危害”，但我倾向于避免将静态成员用于常量文本以外的任何内容，而是更喜欢使用依赖项注入来连接依赖项。但这可能是一个非常简单的项目，引入DI框架超出了您希望引入的复杂性。这完全取决于你的特定环境

此外，我想知道使用2的兴趣是什么 只有一个眩晕可以治疗眩晕

---

同样，这取决于你的环境和你的“复杂性预算”。如果处理过程很简单，并且您希望保持设计同样简单，那么一个竖线就可以了（而且可以说更容易理解/概念化和支持）。在更大的应用程序中，我倾向于沿着不同的逻辑域创建许多垂直链接（例如用于身份验证的垂直链接、用于用户帐户功能的垂直链接等），并通过

EventBus

协调任何复杂的处理

非常感谢你的回答。在良好实践方面，你认为我的代码怎么样