#11 - Add @primary and @secondary

Author: rbygrave

src/main/java/io/dinject/Primary.java

@@ -0,0 +1,25 @@
+package io.dinject;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Identify a bean as being the preferred bean to inject when multiple beans implement
+ * the intended interface.
+ *
+ * <pre>{@code
+ *
+ * @Primary
+ * @Singleton
+ * class PreferredEmailSender implements EmailSender {
+ *
+ *   ...
+ * }
+ * }</pre>
+ */
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Primary {
+}

src/main/java/io/dinject/Secondary.java

@@ -0,0 +1,29 @@
+package io.dinject;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Identify a bean as being the least preferred bean to inject when multiple beans implement
+ * the intended interface.
+ * <p>
+ * This can use be used when we have a 'default' implementation that would only be used when
+ * no other implementation is available in the context to inject.
+ * </p>
+ *
+ * <pre>{@code
+ *
+ * @Secondary
+ * @Singleton
+ * class DefaultEmailSender implements EmailSender {
+ *
+ *   ...
+ * }
+ * }</pre>
+ */
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Secondary {
+}

src/main/java/io/dinject/core/Builder.java

@@ -64,6 +64,16 @@ public interface Builder {
    */
   void register(Object bean, String name, Class<?>... types);
 
+  /**
+   * Register the bean as a Primary bean.
+   */
+  void registerPrimary(Object bean, String name, Class<?>... types);
+
+  /**
+   * Register the bean as a secondary bean.
+   */
+  void registerSecondary(Object bean, String name, Class<?>... types);
+
   /**
    * Add a lifecycle bean.
    */

src/main/java/io/dinject/core/DBeanMap.java

@@ -5,6 +5,10 @@
 import java.util.List;
 import java.util.Map;
 
+import static io.dinject.core.Flag.NORMAL;
+import static io.dinject.core.Flag.PRIMARY;
+import static io.dinject.core.Flag.SECONDARY;
+
 /**
  * Map of types (class types, interfaces and annotations) to a DContextEntry where the
  * entry holds a list of bean instances for that type.
@@ -45,7 +49,7 @@ private void addSuppliedBean(Object bean) {
     Named annotation = suppliedClass.getAnnotation(Named.class);
     String name = (annotation == null) ? null : annotation.value();
 
-    DContextEntryBean entryBean = DContextEntryBean.of(bean, name);
+    DContextEntryBean entryBean = DContextEntryBean.of(bean, name, PRIMARY);
     beans.computeIfAbsent(suppliedType.getCanonicalName(), s -> new DContextEntry()).add(entryBean);
     for (Class<?> anInterface : suppliedClass.getInterfaces()) {
       beans.computeIfAbsent(anInterface.getCanonicalName(), s -> new DContextEntry()).add(entryBean);
@@ -65,9 +69,21 @@ private Class<?> suppliedType(Class<?> suppliedClass) {
     }
   }
 
+  void registerPrimary(Object bean, String name, Class<?>... types) {
+    registerWith(PRIMARY, bean, name, types);
+  }
+
+  void registerSecondary(Object bean, String name, Class<?>... types) {
+    registerWith(SECONDARY, bean, name, types);
+  }
+
   void register(Object bean, String name, Class<?>... types) {
+    registerWith(NORMAL, bean, name, types);
+  }
+
+  void registerWith(int flag, Object bean, String name, Class<?>... types) {
 
-    DContextEntryBean entryBean = DContextEntryBean.of(bean, name);
+    DContextEntryBean entryBean = DContextEntryBean.of(bean, name, flag);
     beans.computeIfAbsent(bean.getClass().getCanonicalName(), s -> new DContextEntry()).add(entryBean);
 
     if (types != null) {

src/main/java/io/dinject/core/DBuilder.java

@@ -179,6 +179,16 @@ public void register(Object bean, String name, Class<?>... types) {
     beanMap.register(bean, name, types);
   }
 
+  @Override
+  public void registerPrimary(Object bean, String name, Class<?>... types) {
+    beanMap.registerPrimary(bean, name, types);
+  }
+
+  @Override
+  public void registerSecondary(Object bean, String name, Class<?>... types) {
+    beanMap.registerSecondary(bean, name, types);
+  }
+
   @Override
   public void addLifecycle(BeanLifecycle wrapper) {
     lifecycleList.add(wrapper);
@@ -213,7 +223,11 @@ public <T> T get(Class<T> cls, String name) {
       if (name != null) {
         msg += " name:" + name;
       }
-      msg += " when creating " + injectTarget;
+      List<T> beanList = getList(cls);
+      msg += " when creating " + injectTarget + " - potential beans to inject: " + beanList;
+      if (!beanList.isEmpty()) {
+        msg += ". Check @Named or Qualifier being used";
+      }
       throw new IllegalStateException(msg);
     }
     return bean;

src/main/java/io/dinject/core/DContextEntry.java

@@ -23,29 +23,10 @@ Object get(String name) {
       DContextEntryBean entry = entries.get(0);
       return entry.getIfMatchWithDefault(name);
     }
-    List<Object> beans = allMatches(name);
-    if (beans.isEmpty()) {
-      return null;
-    }
-    if (beans.size() == 1) {
-      return beans.get(0);
-    } else {
-      throw new IllegalStateException("Expecting only 1 bean match but found " + beans.size() + " beans: " + beans);
-    }
-  }
 
-  /**
-   * Return all the beans that match on the given name.
-   */
-  List<Object> allMatches(String name) {
-    List<Object> beans = new ArrayList<>();
-    for (DContextEntryBean entry : entries) {
-      if (entry.isNameMatch(name)) {
-        beans.add(entry.getBean());
-      }
-    }
-
-    return beans;
+    EntryMatcher matcher = new EntryMatcher(name);
+    matcher.match(entries);
+    return matcher.getBean();
   }
 
   /**
@@ -61,4 +42,64 @@ void add(DContextEntryBean entryBean) {
     entries.add(entryBean);
   }
 
+  static class EntryMatcher {
+
+    private final String name;
+
+    private DContextEntryBean match;
+    private DContextEntryBean ignoredSecondaryMatch;
+
+    EntryMatcher(String name) {
+      this.name = name;
+    }
+
+    void match(List<DContextEntryBean> entries) {
+      for (DContextEntryBean entry : entries) {
+        if (entry.isNameMatch(name)) {
+          checkMatch(entry);
+        }
+      }
+    }
+
+    private void checkMatch(DContextEntryBean entry) {
+      if (match == null) {
+        match = entry;
+        return;
+      }
+      if (match.isSecondary() && !entry.isSecondary()) {
+        // secondary loses
+        match = entry;
+        return;
+      }
+      if (match.isPrimary()) {
+        if (entry.isPrimary()) {
+          throw new IllegalStateException("Expecting only 1 bean match but have multiple primary beans " + match.getBean() + " and " + entry.getBean());
+        }
+        // leave as is, current primary wins
+        return;
+      }
+      if (entry.isSecondary()) {
+        if (match.isSecondary()) {
+          ignoredSecondaryMatch = entry;
+        }
+        return;
+      }
+      if (entry.isPrimary()) {
+        // new primary wins
+        match = entry;
+        return;
+      }
+      throw new IllegalStateException("Expecting only 1 bean match but have multiple matching beans " + match.getBean() + " and " + entry.getBean());
+    }
+
+    Object getBean() {
+      if (match == null) {
+        return null;
+      }
+      if (match.isSecondary() && ignoredSecondaryMatch != null) {
+        throw new IllegalStateException("Expecting only 1 bean match but have multiple secondary beans " + match.getBean() + " and " + ignoredSecondaryMatch.getBean());
+      }
+      return match.getBean();
+    }
+  }
 }

src/main/java/io/dinject/core/DContextEntryBean.java

@@ -13,22 +13,26 @@ class DContextEntryBean {
    *
    * @param bean The bean itself or provider of the bean
    * @param name The optional name for the bean
+   * @param flag The flag for primary, secondary or normal
    */
-  public static DContextEntryBean of(Object bean, String name) {
+  public static DContextEntryBean of(Object bean, String name, int flag) {
     if (bean instanceof Provider) {
-      return new DContextEntryBean.Prov(bean, name);
+      return new DContextEntryBean.Prov(bean, name, flag);
     } else {
-      return new DContextEntryBean(bean, name);
+      return new DContextEntryBean(bean, name, flag);
     }
   }
 
-  protected final Object source;
+  final Object source;
 
   private final String name;
 
-  private DContextEntryBean(Object source, String name) {
+  private final int flag;
+
+  private DContextEntryBean(Object source, String name, int flag) {
     this.source = source;
     this.name = name;
+    this.flag = flag;
   }
 
   boolean isNameMatch(String name) {
@@ -52,15 +56,23 @@ Object getIfMatchWithDefault(String name) {
     }
   }
 
+  boolean isPrimary() {
+    return flag == Flag.PRIMARY;
+  }
+
+  boolean isSecondary() {
+    return flag == Flag.SECONDARY;
+  }
+
   /**
    * Provider based entry - get it once.
    */
   static class Prov extends DContextEntryBean {
 
     private Object actualBean;
 
-    private Prov(Object provider, String name) {
-      super(provider, name);
+    private Prov(Object provider, String name, int flag) {
+      super(provider, name, flag);
     }
 
     @Override

src/main/java/io/dinject/core/Flag.java

@@ -0,0 +1,11 @@
+package io.dinject.core;
+
+/**
+ * Flags to map to <code>@Primary</code> and <code>@Secondary</code>
+ */
+class Flag {
+
+  static final int PRIMARY = 1;
+  static final int NORMAL = 0;
+  static final int SECONDARY = -1;
+}