Vert.x无参构造Verticle的复杂配置（含DAO、gRPC Stub）最佳实践

当需要给无参构造的Verticle传递DAO、gRPC存根这类无法序列化到JsonObject的复杂对象时，以下是几种替代全局静态Map的最佳实践：

1. 利用Vert.x的共享数据（Shared Data） #

Vert.x提供了线程安全的共享数据容器，可在Launcher中初始化复杂对象后存入，再在Verticle的start方法中取出。这种方式避免了全局静态变量的强耦合问题，且天然支持多实例部署。

示例代码：

class MyVerticle extends AbstractVerticle {
    @Override
    void start() {
        // 从本地共享Map获取依赖（仅当前Vertx实例可见）
        MyDao dao = vertx.sharedData().getLocalMap("app-dependencies").get("my-dao");
        MyGrpcStub stub = vertx.sharedData().getLocalMap("app-dependencies").get("grpc-stub");
        
        // 业务逻辑处理
    }
}

public class Launcher {
    public static void main(String[] args) {
        // 初始化复杂依赖
        MyDao myDao = new MyDaoImpl();
        MyGrpcStub grpcStub = MyGrpc.newStub(ManagedChannelBuilder.forAddress("localhost", 9090).usePlaintext().build());
        
        Vertx vertx = Vertx.vertx();
        // 将依赖存入共享容器
        vertx.sharedData().getLocalMap("app-dependencies").put("my-dao", myDao);
        vertx.sharedData().getLocalMap("app-dependencies").put("grpc-stub", grpcStub);
        
        // 部署Verticle
        vertx.deployVerticle(
            MyVerticle.class,
            new DeploymentOptions().setInstances(16)
        );
    }
}

若需跨Vertx集群共享依赖，改用getClusterMap，但需确保对象支持序列化（实现Serializable或自定义Vert.x Codec）。

2. 自定义Verticle工厂 #

通过实现VerticleFactory，可以完全控制Verticle实例的创建过程，直接将复杂依赖注入到Verticle中，同时保留通过类名部署的能力。

示例代码：

// 自定义依赖注入Verticle工厂
public class DiVerticleFactory implements VerticleFactory {
    private final MyDao dao;
    private final MyGrpcStub grpcStub;

    public DiVerticleFactory(MyDao dao, MyGrpcStub grpcStub) {
        this.dao = dao;
        this.grpcStub = grpcStub;
    }

    @Override
    public String prefix() {
        return "di"; // 自定义前缀，标识该工厂处理的部署请求
    }

    @Override
    public void createVerticle(String verticleName, ClassLoader classLoader, Promise<Verticle> promise) {
        // 去除前缀，获取实际类名
        String className = verticleName.substring(prefix().length() + 1);
        try {
            Class<?> verticleClass = classLoader.loadClass(className);
            // 创建无参实例并注入依赖
            MyVerticle verticle = (MyVerticle) verticleClass.getDeclaredConstructor().newInstance();
            verticle.setDao(dao);
            verticle.setGrpcStub(grpcStub);
            promise.complete(verticle);
        } catch (Exception e) {
            promise.fail(e);
        }
    }

    @Override
    public boolean blockingCreate() {
        return false;
    }
}

// 修改MyVerticle，添加依赖设置方法
class MyVerticle extends AbstractVerticle {
    private MyDao dao;
    private MyGrpcStub grpcStub;

    public MyVerticle() {
        // 无参构造
    }

    public void setDao(MyDao dao) {
        this.dao = dao;
    }

    public void setGrpcStub(MyGrpcStub grpcStub) {
        this.grpcStub = grpcStub;
    }

    @Override
    void start() {
        // 直接使用注入的依赖
        dao.queryData();
        grpcStub.callRemoteMethod();
    }
}

// Launcher中注册工厂并部署
public class Launcher {
    public static void main(String[] args) {
        MyDao myDao = new MyDaoImpl();
        MyGrpcStub grpcStub = MyGrpc.newStub(ManagedChannelBuilder.forAddress("localhost", 9090).usePlaintext().build());
        
        Vertx vertx = Vertx.vertx();
        // 注册自定义工厂
        vertx.registerVerticleFactory(new DiVerticleFactory(myDao, grpcStub));
        
        // 使用自定义前缀部署Verticle
        vertx.deployVerticle(
            "di:com.example.MyVerticle",
            new DeploymentOptions().setInstances(16)
        );
    }
}

3. 整合依赖注入框架（如Guice） #

Vert.x官方支持与Guice等DI框架整合，通过vertx-guice库可实现依赖的自动注入，无需手动管理对象传递。

示例代码（需引入io.vertx:vertx-guice依赖）：

// 定义Guice模块
public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(MyDao.class).to(MyDaoImpl.class).asEagerSingleton();
        bind(MyGrpcStub.class).toInstance(MyGrpc.newStub(ManagedChannelBuilder.forAddress("localhost", 9090).usePlaintext().build()));
    }
}

// 修改MyVerticle，使用@Inject注入依赖
class MyVerticle extends AbstractVerticle {
    private final MyDao dao;
    private final MyGrpcStub grpcStub;

    @Inject
    public MyVerticle(MyDao dao, MyGrpcStub grpcStub) {
        this.dao = dao;
        this.grpcStub = grpcStub;
    }

    @Override
    void start() {
        // 使用注入的依赖处理业务
    }
}

// Launcher中配置Guice并部署
public class Launcher {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new AppModule());
        Vertx vertx = Vertx.vertx();
        
        // 注册Guice工厂并部署
        vertx.registerVerticleFactory(new GuiceVerticleFactory(injector));
        vertx.deployVerticle(
            "guice:com.example.MyVerticle",
            new DeploymentOptions().setInstances(16)
        );
    }
}

方案对比 #

内容的提问来源于stack exchange，提问作者Anthony Alba