Avaje Jex

Jex.create()
    .get("/", ctx -> ctx.text("hello"))
    .get("/one/{id}", ctx -> ctx.text("one-" + ctx.pathParam("id")))
    .filter(
        (ctx, chain) -> {
          System.out.println("before request");
          chain.proceed();
          System.out.println("after request");
        })
    .error(
        IllegalStateException.class,
        (ctx, exception) -> ctx.status(500).text(exception.getMessage()))
    .port(8080)
    .start();

package org.example.hello;
import io.avaje.http.api.Controller;
import io.avaje.http.api.Get;
import java.util.List;

@Controller("/widgets")
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()
  List<Widget> getAll() {
    return List.of(new Widget(1, "Rob"), new Widget(2, "Fi"));
  }
  record Widget(int id, String name){};
}

@Generated("avaje-jex-generator")
@Singleton
public class WidgetController$Route implements Routing.HttpService {
  private final WidgetController controller;
  public WidgetController$Route(WidgetController controller) {
    this.controller = controller;
  }
  @Override
  public void add(Routing routing) {
    routing.get("/widgets/{id}", this::_getById);
    routing.get("/widgets", this::_getAll);
  }
  private void _getById(Context ctx) throws IOException {
    ctx.status(200);
    var id = asInt(ctx.pathParam("id"));
    ctx.json(controller.getById(id));
  }
  private void _getAll(Context ctx) throws IOException {
    ctx.status(200);
    ctx.json(controller.getAll());
  }
}

public class Main {
  public static void main(String[] args ) {
    List<Routing.HttpService> services = // Retrieve HttpServices via DI;
    Jex.create().routing(services).start();
  }
}

Jex app = Jex.create();
Routing routing = Jex.create().routing();
routing.get("/output", ctx -> {
    // some code
    ctx.json(object);
});
//alternatively can use a consumer to configure
app.routing(r ->
   r.post("/input", ctx -> {
    // some code
    ctx.status(201).text("posted");
}));
//or can use convenience methods directly on jex
app.post("/something", ctx -> {
    // some code
    ctx.status(201).html(object);
});

var app = Jex.create();
// the {} syntax does not allow slashes ('/') as part of the parameter
app.get("/hello/{name}", ctx -> ctx.write("Hello: " + ctx.pathParam("name")));
// the <> syntax allows slashes ('/') as part of the parameter
app.get("/hello/<name>", ctx -> ctx.write("Hello: " + ctx.pathParam("name")));

Jex.create()
    .get("/path/*",
       ctx -> ctx.write("You are here because " + ctx.path() + " matches " + ctx.matchedPath())
       ));

Jex.create()
    .filter(
        (ctx, chain) -> {
          System.out.println("before request");
          // proceed to the next filter in the chain, or the endpoint handler if  at the end of
          // the chain
          chain.proceed();
          System.out.println("after request");
        });

var app = Jex.create();

app.error(NullPointerException.class, (ctx, e) -> {
    // handle nullpointers here
});

app.error(Exception.class, (ctx, e) -> {
    // handle general exceptions here
    // will not trigger if more specific exception handler found
});

//custom enum for access roles
enum Access implements Role {
  USER,
  ADMIN
}

public static void main(String[] args) {
  Jex.create()
      .get("/user", ctx -> ctx.text("user"), Access.USER)
      .get("/admin", ctx -> ctx.text("admin"), Access.ADMIN)
      .filter(
          (ctx, chain) -> {
            // some user defined function that determines the role
            Access userRole = getUserRole(ctx);
            // the route's registered roles can be retrieved by the Context interface
            if (!ctx.routeRoles().contains(userRole)) {
              // request can be aborted by throwing an exception or by not calling chain.proceed()
              throw new HttpResponseException(403, "unauthorized");
            }
            chain.proceed();
          });
}

Jex.create()
    .jsonService(new JacksonJsonService())
    .post(
        "/json",
        ctx -> {
          MyBody body = ctx.bodyAsClass(MyBody.class);
          ctx.json(new CustomResponse());
        });

StaticContent singleFile =
    StaticContent.createFile("src/main/resources/example.txt").httpPath("/single").build();
StaticContent directoryCP =
    StaticContent.createCP("/public/").httpPath("/").directoryIndex("index.html").build();
Jex app =
    Jex.create()
        .plugin(singleFile) // will serve the src/main/resources/example.txt
        .plugin(directoryCP); // will serve files from the /public classpath directory

char[] passphrase = "changeit".toCharArray();

try {
  // Load the keystore
  KeyStore ks = KeyStore.getInstance("JKS");
  ks.load(new FileInputStream("keystore.jks"), passphrase);

  // Set up the key manager factory
  KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
  kmf.init(ks, passphrase);

  // Set up the trust manager factory
  TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
  tmf.init(ks);

  // Set up the SSL context
  SSLContext sslContext = SSLContext.getInstance("TLS");
  sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);

  // Create Server
  var https = new HttpsConfigurator(sslContext);

  Jex.create()
      .get("/", ctx -> ctx.text("Hello World"))
      .config(c -> c.httpsConfig(https).port(8443))
      .start();

} catch (Exception e) {

  e.printStackTrace();
}