Improve Routes section

Author: decebals

_posts/2015-05-05-routes.md

@@ -25,25 +25,33 @@ GET("/", new RouteHandler() {
 GET("/", routeContext -> routeContext.send("Hello World"));
 ```
 
-Routes in Pippo are created using methods named after HTTP verbs. For instance, in the previous example, we created a route to handle GET requests to the root of the website. You have a corresponding method in Application for all commonly used HTTP verbs (GET, POST, DELETE, HEAD, PUT). For a basic website, only GET and POST are likely to be used.
+Routes in Pippo are created using methods named after HTTP verbs. For instance, in the previous example, we created a route to handle GET requests to the root of the website. You have a corresponding method in Application for all commonly used HTTP verbs (__GET__, __POST__, __DELETE__, __HEAD__, __PUT__, __PATCH__, __CONNECT__ and __OPTIONS__). For a basic website, only GET and POST are likely to be used.
+Pippo comes with a "pseudo" verb `ANY` that meant the route applied to all HTTP methods/verbs.
+```java
+ANY("/example", new CSRFHandler());
+```
 
 The route that is defined first takes precedence over other matching routes. So the ordering of routes is crucial to the behavior of an application.
 
 Each defined route has an __urlPattern__.
 The route can be static or dynamic:
 
 - `static` ("/", "/hello", "/contacts/1")
-- `dynamic` (regex: "/.*" or parameterized: "/contact/{id}", "/contact/{id: [0-9]+}")
+- `dynamic`
+   - regex ("/.*") 
+   - parameterized ("/contact/{id}", "/contact/{id: [0-9]+}")
 
 As you can see, it's easy to create routes with parameters. A parameter is wrapped by curly braces `{name}` and can optionally specify a regular expression.
 
 You can retrieve the path parameter value for a request in type safe mode using:
 
 ```java
 GET("/contact/{id}", routeContext -> {
+    // retrieve some parameters from request
     int id = routeContext.getParameter("id").toInt(0);
     String action = routeContext.getParameter("action").toString("new");
 
+    // render a template using above parameters
     Map<String, Object> model = new HashMap<>();
     model.put("id", id);
     model.put("action", action)
@@ -57,6 +65,37 @@ If you want to be more rigorous you can use something like:
 GET("/contact/{id: [0-9]+}", routeContext -> ... );
 ```
 
+Pippo comes with some builtin route handlers that can be useful for you:
+- `TemplateHandler` (render a template)
+- `RedirectHandler` (redirect to another route/url)
+- `TrailingSlashHandler` (add or remove the trailing slash to/from path)
+- `CSRFHandler` (generates and validates a CSRF token)
+- `UrlResourceHandler`
+- `ClasspathResourceHandler`
+- `PublicResourceHandler`
+- `WebjarsResourceHandler`
+- `MeteredHandler`, `TimedHandler`, `CountedHandler` (metrics)
+
+and the list can continue.
+
+Now, we will talk a little bit about `TrailingSlashHandler` because is important and the problem that it solves is not so visible.
+If we add a route as in the below example
+```java
+GET("/test", routeContext -> routeContext.send("Test"));
+```
+and we type `localhost/test/` in browser we will se that the result is 404 (not found) http code.
+Of course that `localhost/test` works OK. Explanation for 404 on `localhost/test/` is that we registered a route 
+only for `/test` path.
+To obtain the same result for both urls (with and without `\` character at end) we will use `TrailingSlashHandler` (as before filter)
+```java
+// add trailing slash filter
+ANY("/.*", new TrailingSlashHandler(false)); // remove trailing slash
+
+// add test route
+GET("/test", routeContext -> routeContext.send("Test"));
+```
+Now, if you type `localhost/test` or `localhost/test/` in browser, the result is the same.
+
 #### Named routes
 
 `Named` routes make referring to routes when generating redirects or URLs more convenient. You may specify a name for a route like so:
@@ -184,4 +223,4 @@ In above snippet I added (in DemoApplication) `AdminRoutes` as route group which
 I don't need to know when I create a RouteGroup where the group will be mount. For example I can have a modular web application where each plugin comes with own independent routes (user management -> `UserRoutes`, customer management -> `CustomerRoutes`).  
 
 You can see a more complex example in [Matilda](https://github.com/decebals/matilda/blob/master/src/main/java/ro/fortsoft/matilda/PippoApplication.java#L108) (a real life application built with Pippo).
- 
+