Vert.x 服务代理：就在我将服务方法从返回 Future<T> 更改为 Smallrye Mutiny 的 Uni<T> 后，代码生成失败

Question

我已成功为具有返回方法的服务生成服务代理

Future<T>

，
但就在我根据

API Translation - Smallrye Mutiny Vert.x 绑定更改这些方法以返回 

Uni<T> 后， 当我尝试执行
mvn clean compile

 时，它总是告诉我这个错误消息：

无法为 com.example.beers.BarmanService#giveMeAStaticBeer(java.lang.String) 生成模型：代理方法必须具有 void 或 Fluent 返回值

我需要您的帮助来启发我如何解决它。

我把这些代码放在

GitHub上，这些是一些关键代码：

//BarmanService.java

@VertxGen
@ProxyGen
public interface BarmanService {

    Uni<Beer> giveMeAStaticBeer(String customerName);
    Uni<Integer> getMyBill(String customerName);
    Uni<Void> payMyBill(String customerName);

    static BarmanService createProxy(Vertx vertx, String address) {
        return new BarmanServiceVertxEBProxy(vertx, address);
    }

}

//BarmanServiceImpl.java

public class BarmanServiceImpl implements BarmanService {

    Map<String, Integer> bills;

    public BarmanServiceImpl() {
        this.bills = new HashMap<>();
    }

    @Override
    public Uni<Beer> giveMeAStaticBeer(String customerName) {
        Beer beer = new Beer("Workshop River Stout", "English Stout", 5);
        return Uni.createFrom().item(() -> beer);
    }

    @Override
    public Uni<Integer> getMyBill(String customerName) {
        return Uni.createFrom().item(() -> bills.get(customerName));
    }

    @Override
    public Uni<Void> payMyBill(String customerName) {
        bills.remove(customerName);
        System.out.println("Removed debt of " + customerName);
        return Uni.createFrom().voidItem();
    }
}

//package-info.java

@ModuleGen(groupPackage = "com.example", name = "beers")
package com.example.beers;

import io.vertx.codegen.annotations.ModuleGen;

<!-- //pom.xml -->
    <dependencies>
        <!-- // ... -->
        <dependency>
            <groupId>io.vertx</groupId>
            <artifactId>vertx-codegen</artifactId>
            <classifier>processor</classifier>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>io.vertx</groupId>
            <artifactId>vertx-service-proxy</artifactId>
        </dependency>

        <!-- // ... -->
        <dependency>
            <groupId>io.smallrye.reactive</groupId>
            <artifactId>smallrye-mutiny-vertx-core</artifactId>
            <version>2.30.1</version>
        </dependency>
        <dependency>
            <groupId>io.smallrye.reactive</groupId>
            <artifactId>vertx-mutiny-generator</artifactId>
            <version>2.30.1</version>
        </dependency>
        <!-- // ... -->
    </dependencies>

PS 一开始，当我为具有返回

Future<T>

的方法的服务生成服务代理时，有一个

生成的类返回Uni<T>

，但我不知道如何使用它：

package com.example.mutiny.beers;

@io.smallrye.mutiny.vertx.MutinyGen(com.example.beers.BarmanService.class)
public class BarmanService {

  public static final io.smallrye.mutiny.vertx.TypeArg<BarmanService> __TYPE_ARG = new io.smallrye.mutiny.vertx.TypeArg<>(    obj -> new BarmanService((com.example.beers.BarmanService) obj),
    BarmanService::getDelegate
  );

  private final com.example.beers.BarmanService delegate;
  
  public BarmanService(com.example.beers.BarmanService delegate) {
    this.delegate = delegate;
  }

  public BarmanService(Object delegate) {
    this.delegate = (com.example.beers.BarmanService)delegate;
  }

  /**
   * Empty constructor used by CDI, do not use this constructor directly.
   **/
  BarmanService() {
    this.delegate = null;
  }

  public com.example.beers.BarmanService getDelegate() {
    return delegate;
  }

  @CheckReturnValue
  public io.smallrye.mutiny.Uni<com.example.beers.Beer> giveMeAStaticBeer(String customerName) { 
    return io.smallrye.mutiny.vertx.UniHelper.toUni(delegate.giveMeAStaticBeer(customerName));}

  public com.example.beers.Beer giveMeAStaticBeerAndAwait(String customerName) { 
    return giveMeAStaticBeer(customerName).await().indefinitely();
  }


  public void giveMeAStaticBeerAndForget(String customerName) { 
    giveMeAStaticBeer(customerName).subscribe().with(io.smallrye.mutiny.vertx.UniHelper.NOOP);
  }

  // ...

  public static com.example.mutiny.beers.BarmanService createProxy(io.vertx.mutiny.core.Vertx vertx, String address) { 
    com.example.mutiny.beers.BarmanService ret = com.example.mutiny.beers.BarmanService.newInstance((com.example.beers.BarmanService)com.example.beers.BarmanService.createProxy(vertx.getDelegate(), address));
    return ret;
  }

  public static  BarmanService newInstance(com.example.beers.BarmanService arg) {
    return arg != null ? new BarmanService(arg) : null;
  }

}

Answer 1

我刚刚自己想出来的。即将将服务方式从返回

Future<T>

更改为

Uni<T>

错误的方法我做的：

编辑软件包信息以删除
1. useFutures = true
编辑服务接口并更改返回类型
编辑服务实现并更改返回类型，还更改逻辑
编辑顶点以处理从服务返回的
4. Uni<T>
结果证明我做的前三步是不必要的，

合适的方法

是：

包裹顶点：

io.vertx.mutiny.core.Vertx mutinyVertx = new io.vertx.mutiny.core.Vertx(vertx);

将服务接口的使用方式改为生成的接口

import com.example.mutiny.beers.BarmanService;

使用包裹的顶点：

BarmanService barmanService = BarmanService.createProxy(mutinyVertx, "beers.services.myapplication");

编辑顶点以处理从服务返回的

Uni<T>
4. 我的问题已经解决了，但我不确定手动将 vertx 包裹在 io.vertx.core.Launcher 启动的
MainVerticle

上是否是一个好方法：

io.vertx.mutiny.core.Vertx mutinyVertx = new io.vertx.mutiny.core.Vertx(vertx);

大家有什么建议吗？