Update README.md

Author: SentryMan

README.md

@@ -6,79 +6,95 @@ Http server and client libraries and code generation.
 
 A jax-rs style controllers with annotations (`@Path`, `@Get` ...)
 that is lightweight by using source code generation (annotation processors)
-to generate adapter code for Javalin and Helidon SE.
+to generate adapter code for Javalin and Helidon SE/Nima.
 
 - Lightweight as in 65Kb library + generated source code
-- Full use of Javalin or Helidon SE as desired
+- Full use of Javalin or Helidon SE/Nima as desired
 
 
-## Define a Controller
+## Define a Controller (Note that these APT processors works with both Java and Kotlin.)
 ```java
-package org.example.hello
+package org.example.hello;
 
-import io.avaje.http.api.Controller
-import io.avaje.http.api.Get
-import io.avaje.http.api.Path
+import io.avaje.http.api.Controller;
+import io.avaje.http.api.Get;
+import io.avaje.http.api.Path;
+import java.util.List;
 
 @Path("/widgets")
 @Controller
-class WidgetController(private val hello: HelloComponent) {
-
-  @Get("/:id")
-  fun getById(id : Int): Widget {
-    return Widget(id, "you got it${hello.hello()}")
+public class WidgetController {
+  private final HelloComponent hello;
+  public WidgetController(HelloComponent hello) {
+    this.hello = hello;
+  }
+  
+  @Get("/{id}")
+  Widget getById(int id) {
+    return new Widget(id, "you got it"+ hello.hello());
   }
 
   @Get
-  fun getAll(): MutableList<Widget> {
-
-    val list = mutableListOf<Widget>()
-    list.add(Widget(1, "Rob"))
-    list.add(Widget(2, "Fi"))
-
-    return list
+  List<Widget> getAll() {
+    return List.of(new Widget(1, "Rob"), new Widget(2, "Fi"));
   }
 
-  data class Widget(var id: Int, var name: String)
+  record Widget(int id, String name){};
 }
 
 ```
 
-## Generated source (Javalin)
+## Usage with Javalin
 
-The annotation processor will generate a `$Route` for the controller like below.
-
-Note that this class implements the WebRoutes interface, which means we can
-get all the WebRoutes and register them with Javalin using.
+The annotation processor will generate controller classes implementing the WebRoutes interface, which means we can
+get all the WebRoutes and register them with Javalin using:
 
 ```java
-fun main(args: Array<String>) {
+var routes = BeanScope.builder().build().list(WebRoutes.class); 
 
-  // get all the webRoutes
-  val webRoutes = BeanScope.builder().build().list(WebRoutes::class.java)
+Javalin.create()
+        .routes(() -> routes.forEach(WebRoutes::registerRoutes))
+        .start();
+```
 
-  val javalin = Javalin.create()
 
-  javalin.routes {
-    // register all the routes with Javalin
-    webRoutes.forEach { it.registerRoutes() }
+## Usage with Helidon SE
 
-    // other routes etc as desired
-    ApiBuilder.get("/foo") { ctx ->
-      ctx.html("bar")
-      ctx.status(200)
-    }
-    ...
-  }
+The annotation processor will generate controller classes implementing the Helidon Service interface, which we can use
+get all the Services and register them with Helidon `RoutingBuilder`.
+
+```java
+var routes = BeanScope.builder().build().list(Service.class); 
+var routingBuilder = Routing.builder().register(routes.stream().toArray(Service[]::new));
+WebServer.builder()
+        .addMediaSupport(JacksonSupport.create())
+        .routing(routingBuilder)
+        .build()
+        .start();
+```
 
-  javalin.start(7000)
+## Usage with Helidon Nima
+
+The annotation processor will generate controller classes implementing the Helidon HttpService interface, which we can use
+get all the services and register them with the Helidon `RoutingBuilder`.
+
+```java
+var routes = BeanScope.builder().build().list(HttpService.class); 
+final var builder = HttpRouting.builder();
+
+for (final HttpService httpService : routes) {
+   httpService.routing(builder);
 }
 
+WebServer.builder()
+         .addRouting(builder.build())
+         .build()
+         .start();
 ```
+## Generated sources
 
 ### (Javalin) The generated WidgetController$Route.java is:
 
-
 ```java
 package org.example.hello;
 
@@ -102,7 +118,7 @@ public class WidgetController$Route implements WebRoutes {
   @Override
   public void registerRoutes() {
 
-    ApiBuilder.get("/widgets/:id", ctx -> {
+    ApiBuilder.get("/widgets/{id}", ctx -> {
       int id = asInt(ctx.pathParam("id"));
       ctx.json(controller.getById(id));
       ctx.status(200);
@@ -117,23 +133,52 @@ public class WidgetController$Route implements WebRoutes {
 }
 ```
 
-## Generated source (Helidon SE)
+### (Helidon SE) The generated WidgetController$Route.java is:
+```java
+package org.example.hello;
 
-The annotation processor will generate a `$Route` for the controller like below.
+import static io.avaje.http.api.PathTypeConversion.*;
 
-Note that this class implements the Helidon Service interface, which means we can
-get all the Services and register them with Helidon `RoutingBuilder`.
+import io.avaje.http.api.*;
+import io.helidon.common.http.FormParams;
+import io.helidon.webserver.Handler;
+import io.helidon.webserver.Routing;
+import io.helidon.webserver.ServerRequest;
+import io.helidon.webserver.ServerResponse;
+import io.helidon.webserver.Service;
+import jakarta.inject.Singleton;
+import org.example.hello.WidgetController;
 
+@Generated("io.dinject.helidon-generator")
+@Singleton
+public class WidgetController$Route implements Service {
+
+  private final WidgetController controller;
+
+  public WidgetController$Route(WidgetController controller) {
+    this.controller = controller;
+  }
+
+  @Override
+  public void update(Routing.Rules rules) {
+
+    rules.get("/widgets/{id}", this::_getById);
+    rules.post("/widgets", this::_getAll);
+  }
+
+  private void _getById(ServerRequest req, ServerResponse res) {
+    int id = asInt(req.path().param("id"));
+    res.send(controller.getById(id));
+  }
+
+  private void _getAll(ServerRequest req, ServerResponse res) {
+    res.send(controller.getAll());
+  }
+
+}
 ```
-var routes = BeanScope.builder().build().list(Service.class); 
-var routingBuilder = Routing.builder().register(routes.stream().toArray(Service[]::new));
-WebServer.builder()
-        .addMediaSupport(JacksonSupport.create())
-        .routing(routingBuilder)
-        .build()
-        .start();
-```
-### (Helidon SE) The generated WidgetController$Route.java is:
+
+### (Helidon Nima) The generated WidgetController$Route.java is:
 
 ```java
 package org.example.hello;
@@ -163,7 +208,7 @@ public class WidgetController$Route implements Service {
   @Override
   public void update(Routing.Rules rules) {
 
-    rules.get("/widgets/:id", this::_getById);
+    rules.get("/widgets/{id}", this::_getById);
     rules.post("/widgets", this::_getAll);
   }
 
@@ -179,6 +224,4 @@ public class WidgetController$Route implements Service {
 }
 ```
 
-Note that this APT processor works with both Java and Kotlin.
-