[undertow-dev] How do I handle HTTP Methods in Undertow?

[Stuart Douglas]

Undertow is intended to be a lightweight web server rather than a 
container, so it does not really have any annotation processing 
facilities built in, however it should be fairly easy to implement 
something similar on top of Undertow.

Undertow has a handler called io.undertow.server.RoutingHandler, that 
routes requests based on method and path. If you use this handler it 
should be possible to build a handler chain based on annotations on the 
handler classes.

Note that you don't want to be using reflection in the handleRequest 
method, as reflection is relatively slow. Instead the best approach is 
to read the annotations and boot time and build up the routing map while 
the server is starting.

Stuart

Luke Ambrogio wrote:
> So I've decided to start using Undertow, both as an experiment and due
> to the great results it achieved in benchmark tests. And while I think
> it's fantastic there's a feature which is either missing or I can't find.
>
> I want to develop a RESTful web service so it's important for me to
> identify which HTTP method is being called. Now I can get this from
> RequestMethod in the HttpServerExchange parameter but if had to that for
> every handler that would become tedious.
>
> My solution, which works but feels wrong, is this:
>
> Created an annotation interface called HTTPMethod:
>
> |@Retention(RetentionPolicy.RUNTIME)
> @Target(ElementType.METHOD)
> public  @interface  HTTPMethod  {
>
> public  enum  Method  {
>
>      OTHER,  GET,  PUT,  POST,  DELETE
> }
>
> Method  method()  default  Method.OTHER;|
>
> an "abstract" class (which is not abstract):
>
> |public  abstract  class  RESTfulHandler  implements  HttpHandler  {
>
> @Override
> public  void  handleRequest(HttpServerExchange  hse)  throws  Exception  {
>
>      for  (Method  method:  this.getClass().getDeclaredMethods())  {
>
>          // if method is annotated with @Test
>          if  (method.isAnnotationPresent(HTTPMethod.class))  {
>
>              Annotation  annotation=  method.getAnnotation(HTTPMethod.class);
>              HTTPMethod  test=  (HTTPMethod)  annotation;
>
>              switch  (test.method())  {
>                  case  PUT:
>                      if  (hse.getRequestMethod().toString().equals("PUT"))  {
>                          method.invoke(this);
>                      }
>                      break;
>
>                  case  POST:
>                      if  (hse.getRequestMethod().toString().equals("POST"))  {
>                          method.invoke(this);
>                      }
>                      break;
>
>                  case  GET:
>                      if  (hse.getRequestMethod().toString().equals("GET"))  {
>                          method.invoke(this);
>                      }
>                      break;
>
>                  case  DELETE:
>                      if  (hse.getRequestMethod().toString().equals("DELETE"))  {
>                          method.invoke(this);
>                      }
>                      break;
>                  case  OTHER:
>                      if  (hse.getRequestMethod().toString().equals("OTHER"))  {
>                          method.invoke(this);
>                      }
>                      break;
>              }
>              if  (test.method()  ==  HTTPMethod.Method.PUT)  {
>                  method.invoke(this);
>              }
>          }
>      }
> }|
>
> }
>
> and an implementation of both the above:
>
> |public  class  ItemHandler  extends  RESTfulHandler{
>
> @HTTPMethod(method=GET)
> public  void  getAllItems()
> {
>      System.out.println("GET");
> }
>
> @HTTPMethod(method=POST)
> public  void  addItem()
> {
>      System.out.println("POST");
> }
>
> @HTTPMethod
> public  void  doNothing()
> {
>      System.out.println("OTHERS");
> }|
>
> }
>
> Now as I said, it works, but I'm sure that the abstract class and it's
> implementation have something missing so that they glue correctly. So my
> question is two fold:
>
> 1) Is there a better / proper way to filter HTTP requests in Undertow?
> 2) What is the correct way of using annotations correctly correctly in
> the above case?
>
> Thanks
>
>
> _______________________________________________
> undertow-dev mailing list
> undertow-dev at lists.jboss.org
> https://lists.jboss.org/mailman/listinfo/undertow-dev