Weld Vert.x Extensions

import org.jboss.weld.vertx.VertxConsumer;
import org.jboss.weld.vertx.VertxEvent;

class Foo {
    // VertxConsumer - a qualifier used to specify the address of the message consumer
    // VertxEvent - a Vert.x message wrapper
    void echoConsumer(@Observes @VertxConsumer("echo.address") VertxEvent event) {
        event.setReply(event.getMessageBody());
    }
}

void consumerWithDependencies(@Observes @VertxConsumer("dependencies.address") VertxEvent event, CoolService coolService, StatsService statsService) {
    coolService.process(event.getMessageBody());
    statsService.log(event);
}

void consumerStrikesBack(@Observes @VertxConsumer("publish.address") VertxEvent event) {
    event.messageTo("test.huhu.address").publish("huhu");
}

@Dependent
class MyVerticle extends AbstractVerticle {

     @Inject
     Service service;

     @Override
     public void start() throws Exception {
         vertx.eventBus().consumer("my.address").handler(m -> m.reply(service.process(m.body())));
     }
}

class MyApp {
     public static void main(String[] args) {
         Vertx vertx = Vertx.vertx();
         WeldVerticle weldVerticle = new WeldVerticle();
         vertx.deployVerticle(weldVerticle, r -> {
             if (r.succeeded()) {
                 // Deploy Verticle instance produced by Weld
                 MyVerticle myVerticle = weldVerticle.container().select(MyBeanVerticle.class).get();
                 vertx.deployVerticle(myVerticle);
             }
         });
     }
}

@ApplicationScoped
class Hello {

    @Inject
    AsynReference<ServiceWithBlockingInit> service;

    CompletionStage<String> hello() {
        return service.thenApply(s -> "Hello" + s.getName() + "!");
    }
}

@Dependent
public class Hello {

    @Inject
    AsyncWorker worker;

    @Inject
    Service service;

    CompletionStage<String> hello() {
        return worker.performBlocking(service::getMessageFromDb).thenApply(m -> "Hello " + m + "!");
    }
}

public class HelloCombo {

    @Inject
    AsyncWorker worker;

    @Inject
    AsyncReference<Service> serviceRef;

    CompletionStage<String> hello() {
        return serviceRef.thenCompose(service ->
        // At this point Service is ready
        // But getMessage() is also blocking
        worker.performBlocking(service::getMessage)
                // Finally modify the final message
                .thenApply(m -> "Hello " + m + "!"));
    }

}

import org.jboss.weld.vertx.web.WebRoute;
import io.vertx.core.Handler;
import io.vertx.ext.web.RoutingContext;

@WebRoute("/hello") // Matches all HTTP methods
class HelloWorldHandler implements Handler<RoutingContext> {

    @Override
    public void handle(RoutingContext ctx) {
        ctx.response().setStatusCode(200).end("Hello world!");
    }
}

import org.jboss.weld.vertx.web.WebRoute;
import io.vertx.ext.web.RoutingContext;

@ApplicationScoped
class HelloWorld {

    @WebRoute("/hello") // Matches all HTTP methods
    void hello(@Observes RoutingContext ctx) {
        ctx.response().setStatusCode(200).end("Hello world!");
    }
}

import static org.jboss.weld.vertx.web.WebRoute.HandlerType.BLOCKING;
import javax.inject.Inject;
import javax.enterprise.context.control.ActivateRequestContext;

@WebRoute("/hello", type = BLOCKING) // A blocking request handler
public class HelloHandler implements Handler<RoutingContext> {

    @Inject
    SayHelloService service;

    // Interceptor binding used to activate CDI request context within a handle() invocation
    @ActivateRequestContext
    @Override
    public void handle(RoutingContext ctx) {
        ctx.response().setStatusCode(200).end(service.hello());
    }
}

import org.jboss.weld.vertx.web.WebRoute;
import io.vertx.core.Handler;
import io.vertx.core.http.HttpMethod;
import io.vertx.ext.web.RoutingContext;

@WebRoute("/hello", methods = HttpMethod.GET)
@WebRoute("/bye")
public class SuperHandler implements Handler<RoutingContext> {

    @Override
    public void handle(RoutingContext ctx) {
        // This method will be invoked upon the same handler instance for both routes
        ctx.response().setStatusCode(200).end("I'm super!");
    }
}

 class MyApp {

     public static void main(String[] args) {
         Vertx vertx = Vertx.vertx();
         WeldWebVerticle weldVerticle = new WeldWebVerticle();
         vertx.deployVerticle(weldVerticle, result -> {
             if (result.succeeded()) {
                 // Configure the router after Weld bootstrap finished
                 vertx.createHttpServer().requestHandler(weldVerticle.createRouter()::accept).listen(8080);
             }
         });
     }
 }

@ApplicationScoped
public class EchoServiceConsumer {

    // Injects a service proxy for a service with the given address
    @Inject
    @ServiceProxy("echo-service-address")
    EchoService service;

    @Inject
    @Echo
    Event<String> event;

    public void doEchoBusiness(String value) {
        // By default, the result handler is executed by means of Vertx.executeBlocking()
        // In this case, we fire a CDI event observed by EchoObserver bean
        service.echo(value, (r) -> event.fire(r.result()));
    }

}