Use custom API for attributes

- replace service map with attributes
- replace locals with attributes
- introduce registry as bridge interface for DI provider

Author: jknack

jooby/src/main/java/io/jooby/AttributeKey.java

@@ -0,0 +1,71 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Objects;
+
+public class AttributeKey<T> {
+
+  private final Class<T> type;
+  private final String name;
+  private final int hashCode;
+
+  public AttributeKey(@Nonnull Class<T> type, @Nonnull String name) {
+    this.type = type;
+    this.name = name;
+    this.hashCode = type.hashCode() * 31 + name.hashCode();
+  }
+
+  public AttributeKey(@Nonnull Class<T> type) {
+    this.type = type;
+    this.name = null;
+    this.hashCode = type.hashCode();
+  }
+
+  public @Nullable String getName() {
+    return name;
+  }
+
+  public @Nonnull Class<T> getType() {
+    return type;
+  }
+
+  @Override public int hashCode() {
+    return hashCode;
+  }
+
+  @Override public boolean equals(Object obj) {
+    if (this == obj) {
+      return true;
+    }
+    if (obj instanceof AttributeKey) {
+      AttributeKey that = (AttributeKey) obj;
+      return Objects.equals(name, that.name) && type.equals(that.type);
+    }
+    return false;
+  }
+
+  @Override public String toString() {
+    StringBuilder string = new StringBuilder();
+    string.append(type.getTypeName());
+    if (name != null) {
+      string.append(".").append(name);
+    }
+    return string.toString();
+  }
+}

jooby/src/main/java/io/jooby/AttributeMap.java

@@ -0,0 +1,90 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.function.Function;
+
+public class AttributeMap {
+
+  private Map<AttributeKey, Object> map;
+
+  public AttributeMap(Map<AttributeKey, Object> map) {
+    this.map = map;
+  }
+
+  public AttributeMap() {
+    this(new HashMap<>());
+  }
+
+  public boolean contains(@Nonnull AttributeKey<?> key) {
+    return map.containsKey(key);
+  }
+
+  public @Nullable <V> V computeIfAbsent(@Nonnull AttributeKey<V> key,
+      @Nonnull Throwing.Function<AttributeKey<V>, V> mappingFunction) {
+    Function fn = mappingFunction;
+    return (V) map.computeIfAbsent(key, fn);
+  }
+
+  public @Nonnull <V> V get(@Nonnull AttributeKey<V> key) {
+    V value = (V) map.get(key);
+    if (value == null) {
+      throw new NoSuchElementException(key.toString());
+    }
+    return value;
+  }
+
+  public @Nullable <V> V getOrNull(@Nonnull AttributeKey<V> key) {
+    return (V) map.get(key);
+  }
+
+  public @Nonnull <V> V getOrDefault(@Nonnull AttributeKey<V> key, @Nonnull V value) {
+    return (V) map.getOrDefault(key, value);
+  }
+
+  public @Nullable <V> V put(@Nonnull AttributeKey<V> key, @Nonnull V value) {
+    return (V) map.put(key, value);
+  }
+
+  public @Nullable <V> V putIfAbsent(@Nonnull AttributeKey<V> key, @Nonnull V value) {
+    return (V) map.putIfAbsent(key, value);
+  }
+
+  public @Nullable <V> V remove(@Nonnull AttributeKey<V> key) {
+    return (V) map.remove(key);
+  }
+
+  public @Nonnull Set<AttributeKey> keySet() {
+    return map.keySet();
+  }
+
+  public Map<String, Object> toMap() {
+    Map<String, Object> result = new HashMap<>();
+    for (Map.Entry<AttributeKey, Object> entry : map.entrySet()) {
+      AttributeKey key = entry.getKey();
+      if (key.getName() != null) {
+        result.put(key.getName(), entry.getValue());
+      }
+    }
+    return result;
+  }
+}

jooby/src/main/java/io/jooby/Context.java

@@ -60,6 +60,8 @@ public interface Context {
    * **********************************************************************************************
    */
 
+  @Nonnull AttributeMap attributes();
+
   @Nonnull Router router();
 
   /**
@@ -310,12 +312,6 @@ default long contentLength() {
 
   @Nonnull Context detach(@Nonnull Runnable action);
 
-  @Nullable <T> T attribute(@Nonnull String name);
-
-  @Nonnull Context attribute(@Nonnull String name, @Nonnull Object value);
-
-  @Nonnull Map<String, Object> attributes();
-
   /**
    * **********************************************************************************************
    * **** Response methods *************************************************************************

jooby/src/main/java/io/jooby/Jooby.java

@@ -31,6 +31,7 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.NoSuchElementException;
 import java.util.ServiceLoader;
 import java.util.Spliterator;
 import java.util.concurrent.Executor;
@@ -44,7 +45,7 @@
 import static java.util.Spliterators.spliteratorUnknownSize;
 import static java.util.stream.StreamSupport.stream;
 
-public class Jooby implements Router {
+public class Jooby implements Router, Registry {
 
   private RouterImpl router;
 
@@ -60,8 +61,6 @@ public class Jooby implements Router {
 
   private LinkedList<Throwing.Runnable> stopCallbacks;
 
-  private Map<Object, Object> services = new HashMap<>();
-
   /**
    * Not ideal but useful. We want to have access to environment properties from instance
    * initializer. So external method before creating a new Jooby instance does a call to
@@ -72,6 +71,8 @@ public class Jooby implements Router {
 
   protected Env environment;
 
+  private Registry registry;
+
   public Jooby() {
     router = new RouterImpl(new RouteAnalyzer(getClass().getClassLoader(), false));
     environment = ENV.get();
@@ -286,50 +287,36 @@ public Jooby errorCode(@Nonnull Class<? extends Throwable> type,
     return this;
   }
 
-  public @Nonnull <T> T require(@Nonnull Class<T> type) {
-    return findService(type, type.getName());
+  @Nonnull @Override public AttributeMap attributes() {
+    return router.attributes();
   }
 
   public @Nonnull <T> T require(@Nonnull Class<T> type, @Nonnull String name) {
-    return findService(type, type.getName() + "." + name);
-  }
-
-  private @Nonnull <T> T findService(@Nonnull Class<T> type, @Nonnull String key) {
-    Object service = services.get(key);
-    if (service == null) {
-      throw new IllegalStateException("Service not found: " + type);
-    }
-    return type.cast(service);
-  }
-
-  public @Nonnull <T> Jooby addService(@Nonnull Class<T> type, @Nonnull T service) {
-    putService(type, null, service);
-    return this;
-  }
-
-  public @Nonnull <T> Jooby addService(@Nonnull T service) {
-    putService(service.getClass(), null, service);
-    return this;
+    return require(new AttributeKey<>(type, name));
   }
 
-  public @Nonnull <T> Jooby addService(@Nonnull String name, @Nonnull T service) {
-    putService(service.getClass(), name, service);
-    return this;
+  public @Nonnull <T> T require(@Nonnull Class<T> type) {
+    return require(new AttributeKey<>(type));
   }
 
-  public @Nonnull <T> Jooby addService(@Nonnull Class<T> type, @Nonnull String name, @Nonnull T service) {
-    putService(type, name, service);
+  public @Nonnull Jooby registry(@Nonnull Registry registry) {
+    this.registry = registry;
     return this;
   }
 
-  private void putService(@Nonnull Class type, String name, @Nonnull Object service) {
-    String defkey = type.getName();
-    String key = type.getName();
-    if (name != null) {
-      key += "." + name;
+  private <T> T require(AttributeKey<T> key) {
+    AttributeMap attributes = attributes();
+    if (attributes.contains(key)) {
+      return attributes.get(key);
+    }
+    if (registry != null) {
+      String name = key.getName();
+      if (name == null) {
+        return registry.require(key.getType());
+      }
+      return registry.require(key.getType(), name);
     }
-    services.put(key, service);
-    services.putIfAbsent(defkey, service);
+    throw new NoSuchElementException(key.toString());
   }
 
   /** Boot: */
@@ -420,7 +407,8 @@ public static void run(@Nonnull Supplier<Jooby> provider, String... args) {
     run(provider, ExecutionMode.DEFAULT, args);
   }
 
-  public static void run(@Nonnull Supplier<Jooby> provider, @Nonnull ExecutionMode mode, String... args) {
+  public static void run(@Nonnull Supplier<Jooby> provider, @Nonnull ExecutionMode mode,
+      String... args) {
     Server server;
     try {
       Env environment = Env.defaultEnvironment(args);

jooby/src/main/java/io/jooby/Registry.java

@@ -0,0 +1,24 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby;
+
+import javax.annotation.Nonnull;
+
+public interface Registry {
+  @Nonnull <T> T require(@Nonnull Class<T> type);
+
+  @Nonnull <T> T require(@Nonnull Class<T> type, @Nonnull String name);
+}

jooby/src/main/java/io/jooby/Router.java

@@ -57,6 +57,8 @@ interface Match {
   List<String> METHODS = unmodifiableList(
       asList(GET, POST, PUT, DELETE, PATCH, HEAD, CONNECT, OPTIONS, TRACE));
 
+  @Nonnull AttributeMap attributes();
+
   @Nonnull Router caseSensitive(boolean caseSensitive);
 
   @Nonnull Router ignoreTrailingSlash(boolean ignoreTrailingSlash);

jooby/src/main/java/io/jooby/Throwing.java

@@ -149,7 +149,7 @@ public interface Consumer<V> extends java.util.function.Consumer<V> {
    * @param <V2> Input type.
    */
   @FunctionalInterface
-  public interface Consumer2<V1, V2> {
+  public interface Consumer2<V1, V2> extends java.util.function.BiConsumer<V1, V2> {
     /**
      * Performs this operation on the given argument.
      *

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

@@ -15,6 +15,7 @@
  */
 package io.jooby.internal;
 
+import io.jooby.AttributeMap;
 import io.jooby.ErrorHandler;
 import io.jooby.Jooby;
 import io.jooby.Context;
@@ -39,6 +40,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executor;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
@@ -125,11 +127,17 @@ public Stack executor(Executor executor) {
 
   private Map<String, Parser> parsers = new HashMap<>();
 
+  private AttributeMap attributes = new AttributeMap(new ConcurrentHashMap<>());
+
   public RouterImpl(RouteAnalyzer analyzer) {
     this.analyzer = analyzer;
     stack.addLast(new Stack(""));
   }
 
+  @Nonnull @Override public AttributeMap attributes() {
+    return attributes;
+  }
+
   @Nonnull @Override public Router caseSensitive(boolean caseSensitive) {
     this.caseSensitive = caseSensitive;
     chi.setCaseSensitive(caseSensitive);