@Path("hello")
public class HelloWorld {
    @GET
    public String hello() {
        return "Hello World";
    }
}

<dependency>
  <groupId>io.helidon.microprofile.bundles</groupId>
  <artifactId>helidon-microprofile</artifactId>
</dependency>

<dependency>
  <groupId>io.helidon.microprofile.bundles</groupId>
  <artifactId>helidon-microprofile-core</artifactId>
</dependency>

@Path("/")
@RequestScoped
public class HelloWorldResource {
    @GET
    @Produces(MediaType.TEXTPLAIN)
    public String message() {
        return "Hello World";
    }
}

@ApplicationScoped
@ApplicationPath("/")
public class HelloWorldApplication extends Application {
    @Override
    public Set<Class<?>> getClasses() {
        return Set.of(
                HelloWorldResource.class
        );
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans/>

public static void main(String[] args) {
    io.helidon.microprofile.server.Main.main(args);
}

mvn -U archetype:generate -DinteractiveMode=false \
    -DarchetypeGroupId=io.helidon.archetypes \
    -DarchetypeArtifactId=helidon-quickstart-mp \
    -DarchetypeVersion=2.1.0 \
    -DgroupId=io.helidon.examples \
    -DartifactId=helidon-quickstart-mp \
    -Dpackage=io.helidon.examples.quickstart.mp

curl -X GET http://localhost:8080/greet
{"message":"Hello World!"}
curl -X GET http://localhost:8080/greet/Joe
{"message":"Hello Joe!"}
curl -X PUT -H "Content-Type: application/json" -d '{"greeting" : "Hola"}' http://localhost:8080/greet/greeting
curl -X GET http://localhost:8080/greet/Jose
{"message":"Hola Jose!"}

Routing routing = Routing.builder()
    .get("/hello", (req, res) ->
     res.send("Hello World"))
    .build();
WebServer.create(routing)
   .start();

dbClient.inTransaction(tx -> tx
    .createQuery("SELECT name FROM Pokemons WHERE id = :id")
    .addParam("id", 1)
    .execute()
);  

dbClient.execute(exec -> exec
    .createUpdate("{"collection": "pokemons","
        + ""value":{$set:{"name":$name}},"
        + ""query":{id:$id}}")
    .addParam("id", 1)
    .addParam("name", "Pikachu")
    .execute()
);

db:
  source: "jdbc" 
  connection:
    url: "jdbc:mysql://127.0.0.1:3306/pokemon?useSSL=false" 
    username: "user"
    password: "password"
  statements: 
    ping: "DO 0" 
    select-all-pokemons: "SELECT id, name FROM Pokemons"

WebClient client = WebClient.builder()
        .baseUri("http://localhost")
        .build();
Single<String> response = client.get()
        .path("/endpoint")
        .request(String.class); 

AtomicInteger sum = new AtomicInteger();
Multi.just("1", "2", "3", "4", "5")
        .limit(3)
        .map(Integer::parseInt)
        .forEach(sum::addAndGet);
System.out.println("Sum: " + sum.get());
> Sum: 6

Single.just("1")
        .map(Integer::parseInt)
        .map(i -> i + 5)
        .toStage()
        .whenComplete((i, t) -> System.out.println("Result: " + i));
> Result: 6

public static void main(String[] args) throws Exception {
      // Implement the simplest possible gRPC service.  
      GrpcServer grpcServer = GrpcServer
                      .create(GrpcRouting.builder()
                      .register(new HelloService()) 
                      .build())
                      .start() 
                      .toCompletableFuture()
                      .get(10, TimeUnit.SECONDS); 
      System.out.println("gRPC Server started at: http://localhost:"
      + grpcServer.port()); 
}
static class HelloService implements GrpcService { 
    @Override
    public void update(ServiceDescriptor.Rules rules) {
         rules.unary("SayHello", ((request, responseObserver) -> complete(responseObserver, "Hello " + request))); 
    }
}

public static void main(String[] args) throws Exception {
    // Дескриптор gRPC, который использует унарный метод. По умолчанию, Java 
    // сериализация, сериализация и десериализация.
    ClientServiceDescriptor descriptor = ClientServiceDescriptor
      .builder(HelloService.class)
      .unary("SayHello")
      .build();
    // Создаем канал на порту 1408 
    Channel channel = ManagedChannelBuilder.forAddress("localhost", 1408)                           
                                               .usePlaintext()
                                               .build();
    // Ну и инициализируем непосредственно клиент 
    GrpcServiceClient client = GrpcServiceClient.create(channel, descriptor);                   
    // Теперь можно вызывать метод SayHello, который возвращает CompletableFuture
    CompletionStage<String> future = client.unary("SayHello", "Helidon gRPC!!"); 
    // С чистой совестью печатаем результат!                
    System.out.println(future.get());                                                           
}

<dependency>
    <groupId>io.helidon.microprofile.tests</groupId>
    <artifactId>helidon-microprofile-tests-junit5</artifactId>
    <scope>test</scope>
</dependency>

@HelidonTest
@DisableDiscovery
@AddBean(MyBean.class)
@AddExtension(ConfigCdiExtension.class)
@AddConfig(key = "app.greeting", value = "TestHello")
class TestNoDiscovery {
    @Inject
    private MyBean myBean;
    @Test
    void testGreeting() {
        assertThat(myBean, notNullValue());
        assertThat(myBean.greeting(), is("TestHello"));
    }
}