routing: yet another micro optimization for static path

- remove the use of hashmap for single method matching

Author: jknack

jooby/src/main/java/io/jooby/internal/Chi.java

@@ -10,7 +10,6 @@
 import io.jooby.Router;
 
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
@@ -31,24 +30,71 @@ class Chi implements RouteTree {
 
   private static final int NODE_SIZE = ntCatchAll + 1;
 
-  static final StaticRoute NO_MATCH = new StaticRoute(Collections.emptyMap());
-
   static final char ZERO_CHAR = (char) 0;
   private MessageEncoder encoder;
 
-  static class StaticRoute {
-    private final Map<String, StaticRouterMatch> methods;
+  private interface MethodMatcher {
+    StaticRouterMatch get(String method);
+
+    void put(String method, StaticRouterMatch route);
+
+    boolean matches(String method);
+  }
+
+  private static class SingleMethodMatcher implements MethodMatcher {
+    private String method;
+    private StaticRouterMatch route;
+
+    @Override public void put(String method, StaticRouterMatch route) {
+      this.method = method;
+      this.route = route;
+    }
+
+    @Override public StaticRouterMatch get(String method) {
+      return this.method.equals(method) ? route : null;
+    }
+
+    @Override public boolean matches(String method) {
+      return this.method.equals(method);
+    }
+
+    public void clear() {
+      this.method = null;
+      this.route = null;
+    }
+  }
+
+  private static class MultipleMethodMatcher implements MethodMatcher {
+    private Map<String, StaticRouterMatch> methods = new ConcurrentHashMap<>();
 
-    public StaticRoute(Map<String, StaticRouterMatch> methods) {
-      this.methods = methods;
+    public MultipleMethodMatcher(SingleMethodMatcher matcher) {
+      methods.put(matcher.method, matcher.route);
+      matcher.clear();
     }
 
-    public StaticRoute() {
-      this(newMap(Router.METHODS.size()));
+    @Override public StaticRouterMatch get(String method) {
+      return methods.get(method);
     }
 
+    @Override public void put(String method, StaticRouterMatch route) {
+      methods.put(method, route);
+    }
+
+    @Override public boolean matches(String method) {
+      return this.methods.containsKey(method);
+    }
+  }
+
+  static class StaticRoute {
+    private MethodMatcher matcher;
+
     public void put(String method, Route route) {
-      methods.put(method, new StaticRouterMatch(route));
+      if (matcher == null) {
+        matcher = new SingleMethodMatcher();
+      } else if (matcher instanceof SingleMethodMatcher) {
+        matcher = new MultipleMethodMatcher((SingleMethodMatcher) matcher);
+      }
+      matcher.put(method, new StaticRouterMatch(route));
     }
   }
 
@@ -555,7 +601,7 @@ Segment patNextSegment(String pattern) {
       int ws = pattern.indexOf('*');
 
       if (ps < 0 && ws < 0) {
-        return new Segment(ntStatic, EMPTY_STRING, (char) 0, 0,
+        return new Segment(ntStatic, EMPTY_STRING, ZERO_CHAR, 0,
             pattern.length()); // we return the entire thing
       }
 
@@ -623,7 +669,7 @@ Segment patNextSegment(String pattern) {
       // EDIT: should we panic if there is stuff after the * ???
       // We allow naming a wildcard: *path
       //String key = ws == pattern.length() - 1 ? "*" : pattern.substring(ws + 1).toString();
-      return new Segment(ntCatchAll, EMPTY_STRING, (char) 0, ws, pattern.length());
+      return new Segment(ntCatchAll, EMPTY_STRING, ZERO_CHAR, ws, pattern.length());
     }
 
     public void destroy() {
@@ -650,11 +696,7 @@ public void destroy() {
   private final Node root = new Node();
 
   /** Not need to use a concurrent map, due we don't allow to add routes after application started. */
-  private final Map<Object, StaticRoute> staticPaths = newMap(16);
-
-  static <K, V> Map<K, V> newMap(int size) {
-    return new ConcurrentHashMap<>(size);
-  }
+  private final Map<Object, StaticRoute> staticPaths = new ConcurrentHashMap<>();
 
   public void insert(String method, String pattern, Route route) {
     String baseCatchAll = baseCatchAll(pattern);
@@ -691,24 +733,27 @@ public void destroy() {
   }
 
   public boolean exists(String method, String path) {
-    if (!staticPaths.getOrDefault(path, NO_MATCH).methods.containsKey(method)) {
-      return root.findRoute(new RouterMatch(), method, path) != null;
-    }
-    return true;
+    return find(method, path) != null;
   }
 
   @Override public Router.Match find(String method, String path) {
-    StaticRouterMatch match = staticPaths.getOrDefault(path, NO_MATCH).methods.get(method);
-    if (match == null) {
-      // use radix tree
-      RouterMatch result = new RouterMatch();
-      Route route = root.findRoute(result, method, path);
-      if (route == null) {
-        return result.missing(method, path, encoder);
-      }
-      return result.found(route);
+    StaticRoute staticRoute = staticPaths.get(path);
+    if (staticRoute == null) {
+      return findInternal(method, path);
+    } else {
+      StaticRouterMatch match = staticRoute.matcher.get(method);
+      return match == null ? findInternal(method, path) : match;
+    }
+  }
+
+  private Router.Match findInternal(String method, String path) {
+    // use radix tree
+    RouterMatch result = new RouterMatch();
+    Route route = root.findRoute(result, method, path);
+    if (route == null) {
+      return result.missing(method, path, encoder);
     }
-    return match;
+    return result.found(route);
   }
 
   public void setEncoder(MessageEncoder encoder) {