3:04 a.m.
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)(a)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 {
@Overridepublic 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"); }
@HTTPMethodpublic 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
7 p.m.
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:
|(a)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(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/undertow-dev
3:19 a.m.
Thanks Stuart,
I think that's exactly what I need, since annotation as you say might not
be necessary.
Can you specify which version I would need to include in the pom please?
Since the one I am using (1.0.14.Final) doesn't seem to include it and
maven doesn't seem to know about 1.2.0.Beta1-SNAPSHOT.
Cheers
On Thu, Sep 25, 2014 at 2:00 AM, Stuart Douglas <sdouglas(a)redhat.com> wrote:
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:
>
> |(a)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(a)lists.jboss.org
> https://lists.jboss.org/mailman/listinfo/undertow-dev
>
4:12 p.m.
1.1.CR2
1.1.Final should be out soon.
Stuart
Luke Ambrogio wrote:
Thanks Stuart,
I think that's exactly what I need, since annotation as you say might
not be necessary.
Can you specify which version I would need to include in the pom please?
Since the one I am using (1.0.14.Final) doesn't seem to include it and
maven doesn't seem to know about 1.2.0.Beta1-SNAPSHOT.
Cheers
On Thu, Sep 25, 2014 at 2:00 AM, Stuart Douglas <sdouglas(a)redhat.com
<mailto:sdouglas@redhat.com>> wrote:
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:
|(a)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(a)lists.jboss.org <mailto:undertow-dev@lists.jboss.org>
https://lists.jboss.org/__mailman/listinfo/undertow-dev
<https://lists.jboss.org/mailman/listinfo/undertow-dev>
10:31 p.m.
Oops, this should read 1.1.0.CR2 and 1.1.0.Final
Stuart
Stuart Douglas wrote:
1.1.CR2
1.1.Final should be out soon.
Stuart
Luke Ambrogio wrote:
> Thanks Stuart,
>
> I think that's exactly what I need, since annotation as you say might
> not be necessary.
>
> Can you specify which version I would need to include in the pom please?
> Since the one I am using (1.0.14.Final) doesn't seem to include it and
> maven doesn't seem to know about 1.2.0.Beta1-SNAPSHOT.
>
> Cheers
>
> On Thu, Sep 25, 2014 at 2:00 AM, Stuart Douglas<sdouglas(a)redhat.com
> <mailto:sdouglas@redhat.com>> wrote:
>
> 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:
>
> |(a)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@lists.jboss.org<mailto:undertow-dev@lists.jboss.org>
> https://lists.jboss.org/__mailman/listinfo/undertow-dev
> <https://lists.jboss.org/mailman/listinfo/undertow-dev>
>
>
>
_______________________________________________
undertow-dev mailing list
undertow-dev(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/undertow-dev
7:02 p.m.
This looks nice to me. Although for efficiency you would want to initialize the methods
and cache them. If you prefer you could use the servlet API which allows you to filter
methods with annotations as well.
On Sep 24, 2014, at 3:04 AM, Luke Ambrogio <gryzlaw(a)hotmail.com> 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(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/undertow-dev
--
Jason T. Greene
WildFly Lead / JBoss EAP Platform Architect
JBoss, a division of Red Hat
3:28 a.m.
Hi Jason,
thanks for your feedback, there seems to be several solutions better than
mine :)
Cheers
On Thu, Sep 25, 2014 at 2:02 AM, Jason Greene <jason.greene(a)redhat.com>
wrote:
This looks nice to me. Although for efficiency you would want to
initialize the methods and cache them. If you prefer you could use the
servlet API which allows you to filter methods with annotations as well.
On Sep 24, 2014, at 3:04 AM, Luke Ambrogio <gryzlaw(a)hotmail.com> 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(a)lists.jboss.org
> https://lists.jboss.org/mailman/listinfo/undertow-dev
--
Jason T. Greene
WildFly Lead / JBoss EAP Platform Architect
JBoss, a division of Red Hat
4:49 a.m.
Here is a code example of how to use a RouterHandler in a way that I think
you are looking for...
https://gist.github.com/jonathanhart/0aeef8f72b9ef3a4ea78
How you handle the HTTPHandler part is entirely up to you, but this is how
I chose to do it.. but it does illustrate how to use RouterHandler with
HTTP verbs.. You can obviously have the same URL template for different
verbs and route them to different behaviors, as I do by passing in a custom
constructor..
Jonathan
On Thu, Sep 25, 2014 at 1:28 AM, Luke Ambrogio <gryzlaw(a)hotmail.com> wrote:
Hi Jason,
thanks for your feedback, there seems to be several solutions better than
mine :)
Cheers
On Thu, Sep 25, 2014 at 2:02 AM, Jason Greene <jason.greene(a)redhat.com>
wrote:
> This looks nice to me. Although for efficiency you would want to
> initialize the methods and cache them. If you prefer you could use the
> servlet API which allows you to filter methods with annotations as well.
>
> On Sep 24, 2014, at 3:04 AM, Luke Ambrogio <gryzlaw(a)hotmail.com> 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(a)lists.jboss.org
> > https://lists.jboss.org/mailman/listinfo/undertow-dev
>
> --
> Jason T. Greene
> WildFly Lead / JBoss EAP Platform Architect
> JBoss, a division of Red Hat
>
>
>
_______________________________________________
undertow-dev mailing list
undertow-dev(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/undertow-dev
7:26 p.m.
Hi, Luke.
How about using JAX-RS?
Hammock(RESTEasy + Weld + Undertow) might be helpful for your RESTful APIs,
however, it hasn't been updated recently.
https://github.com/johnament/hammock
On Wed, Sep 24, 2014 at 5:04 PM, Luke Ambrogio <gryzlaw(a)hotmail.com> 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)(a)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 {
@Overridepublic 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"); }
@HTTPMethodpublic 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(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/undertow-dev
3514
days inactive
3516
days old
8 comments
5 participants
participants (5)
-
Jason Greene -
Jonathan Hart -
lanabe -
Luke Ambrogio -
Stuart Douglas