Add dynamic method binding

Author: simonwep

README.md

@@ -41,6 +41,7 @@ app.get("/", (req, res) -> {
 
 # Docs:
 * [Routing](#routing)
+   * [DynExpress](#dynexpress)
    * [Direct](#direct)
    * [With Router](#with-router)
 * [URL Basics](#url-basics)
@@ -49,7 +50,7 @@ app.get("/", (req, res) -> {
    * [URL Querys](#url-querys)
    * [Cookies](#cookies)
    * [Form Data](#form-data)
-* [HTTP - Main Classes](#http---main-classes)
+* [HTTP Relevant classes](#http-relevant-classes)
    * [Response Object](#response-object)
    * [Request Object](#request-object)
 * [Middleware](#middleware)
@@ -59,6 +60,52 @@ app.get("/", (req, res) -> {
 * [Examples](#examples)
 
 # Routing
+## DynExpress
+Express allows the attaching of request-handler to instance methods via the DynExpress annotation:
+```java
+
+// Your main class
+import express.Express;
+public class Main {
+    public static void main(String[] args) {
+        Express app = new Express();
+        app.bind(new Bindings()); // See class below
+        app.listen();
+    }
+}
+
+// Your class with request handlers
+import express.DynExpress;
+import express.http.RequestMethod;
+import express.http.request.Request;
+import express.http.response.Response;
+public class Bindings {
+
+    @DynExpress() // Default is context="/" and method=RequestMethod.GET
+    public void getIndex(Request req, Response res) {
+        res.send("Hello World!");
+    }
+
+    @DynExpress(context = "/about") // Only context is defined, method=RequestMethod.GET is used as method
+    public void getAbout(Request req, Response res) {
+        res.send("About page");
+    }
+
+    @DynExpress(context = "/impressum", method = RequestMethod.PATCH) // Both defined
+    public void getImpressum(Request req, Response res) {
+        res.send("Impressum page was patched");
+    }
+
+    @DynExpress(method = RequestMethod.POST) // Only the method is defined, "/" is used as context
+    public void postIndex(Request req, Response res) {
+        res.send("POST to index");
+    }
+}
+
+
+```
+
+
 ## Direct
 You can add routes (And middlewares) directly to the Express object to handle requests:
 ```java
@@ -216,7 +263,7 @@ app.post("/register", (req, res) -> {
 });
 ```
 
-# HTTP - Main Classes
+# HTTP Relevant classes
 ## Express
 This class represents the entire HTTP-Server, the available methods are:
 ```java

src/main/java/express/DynExpress.java

@@ -0,0 +1,20 @@
+package express;
+
+import express.http.RequestMethod;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author Simon Reinisch
+ * Annotation to use object methods as request handler.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface DynExpress {
+    RequestMethod method() default RequestMethod.GET;
+
+    String context() default "/";
+}

src/main/java/express/Express.java

@@ -8,6 +8,8 @@
 import express.filter.FilterTask;
 import express.filter.FilterWorker;
 import express.http.HttpRequestHandler;
+import express.http.request.Request;
+import express.http.response.Response;
 
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
@@ -236,6 +238,75 @@ public Express patch(String context, HttpRequestHandler request) {
         return this;
     }
 
+    /**
+     * Binds a or multiple objects with request-handler methods on this express instance.
+     * With the use of the DynExpress Annotation handler can be declared with a annotation
+     * on a compatible method which has as parameter a Request and Response object.
+     *
+     * @param objects Object with proper request handler methods.
+     * @return This express instance.
+     */
+    public Express bind(Object... objects) {
+        for (Object o : objects) {
+
+            // Skip null objects
+            if (o == null) {
+                continue;
+            }
+
+            // Find methods wich has the DynExpress annotation
+            Method[] methods = o.getClass().getDeclaredMethods();
+            for (Method method : methods) {
+
+                // Validate parameter types
+                Class<?>[] params = method.getParameterTypes();
+                if (params.length < 1 || params[0] != Request.class || params[1] != Response.class) {
+                    StringBuilder sb = new StringBuilder();
+                    for (Class<?> c : params) {
+                        sb.append(c.getSimpleName());
+                        sb.append(", ");
+                    }
+
+                    String paramString = sb.toString();
+                    if (paramString.length() > 2) {
+                        paramString = paramString.substring(0, paramString.length() - 2);
+                    }
+
+                    System.err.println("Skipped method with invalid parameter types found in " +
+                            method.getName() + "(" + paramString + ") in " + o.getClass().getName() +
+                            ". Expected Request and Response.");
+                    continue;
+                }
+
+                // Make private method accessible
+                if (!method.isAccessible()) {
+                    method.setAccessible(true);
+                }
+
+                // Check if dyn-annotation is present
+                if (method.isAnnotationPresent(DynExpress.class)) {
+                    DynExpress[] annotations = method.getAnnotationsByType(DynExpress.class);
+
+                    for (DynExpress dex : annotations) {
+                        String context = dex.context();
+                        String requestMethod = dex.method().getMethod();
+
+                        // Bind to instance
+                        handler.add(1, new FilterImpl(requestMethod, context, (req, res) -> {
+                            try {
+                                method.invoke(o, req, res);
+                            } catch (IllegalAccessException | InvocationTargetException e) {
+                                e.printStackTrace();
+                            }
+                        }));
+                    }
+                }
+            }
+        }
+
+        return this;
+    }
+
     /**
      * Start the HTTP-Server on port 80.
      * This method is asynchronous so be sure to add an listener or keep it in mind!

src/main/java/express/http/RequestMethod.java

@@ -0,0 +1,32 @@
+package express.http;
+
+/**
+ * @author Simon Reinisch
+ * Enum with basic requestmethods.
+ */
+public enum RequestMethod {
+
+    // Real request methods
+    GET("GET"),
+    POST("POST"),
+    PUT("PUT"),
+    PATCH("PATCH"),
+    DELETE("DELETE"),
+    CONNECT("CONNECT"),
+    OPTIONS("OPTIONS"),
+    TRACE("TRACE"),
+    HEAD("HEAD"),
+
+    // Express specific method which will catch every method
+    ALL("*");
+
+    private String method;
+
+    RequestMethod(String method) {
+        this.method = method;
+    }
+
+    public String getMethod() {
+        return method;
+    }
+}