#13 - Support priority of @primary and @secondary across modules

Author: rbygrave

src/main/java/io/dinject/BeanContext.java

@@ -93,6 +93,11 @@ public interface BeanContext extends Closeable {
    */
   <T> T getBean(Class<T> type, String name);
 
+  /**
+   * Return the wiring candidate bean with name and priority.
+   */
+  <T> BeanEntry<T> candidate(Class<T> type, String name);
+
   /**
    * Return the list of beans that have an annotation.
    *

src/main/java/io/dinject/BeanEntry.java

@@ -0,0 +1,43 @@
+package io.dinject;
+
+/**
+ * A bean entry in the context with priority and optional name.
+ */
+public class BeanEntry<T> {
+
+  private final int priority;
+
+  private final T bean;
+
+  private final String name;
+
+  /**
+   * Construct with priorty, name and the bean.
+   */
+  public BeanEntry(int priority, T bean, String name) {
+    this.priority = priority;
+    this.bean = bean;
+    this.name = name;
+  }
+
+  /**
+   * Return the priority (Primary, Normal and Secondary).
+   */
+  public int getPriority() {
+    return priority;
+  }
+
+  /**
+   * Return the bean.
+   */
+  public T getBean() {
+    return bean;
+  }
+
+  /**
+   * Return the bean name.
+   */
+  public String getName() {
+    return name;
+  }
+}

src/main/java/io/dinject/BootContext.java

@@ -260,6 +260,11 @@ public <T> T getBean(Class<T> beanClass, String name) {
       return context.getBean(beanClass, name);
     }
 
+    @Override
+    public <T> BeanEntry<T> candidate(Class<T> type, String name) {
+      return context.candidate(type, name);
+    }
+
     @Override
     public List<Object> getBeansWithAnnotation(Class<?> annotation) {
       return context.getBeansWithAnnotation(annotation);

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

@@ -1,6 +1,7 @@
 package io.dinject.core;
 
 import io.dinject.BeanContext;
+import io.dinject.BeanEntry;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -55,20 +56,25 @@ public <T> T getBean(Class<T> beanClass) {
     return getBean(beanClass, null);
   }
 
-  @SuppressWarnings("unchecked")
   @Override
-  public <T> T getBean(Class<T> beanClass, String name) {
-    T bean = beans.getBean(beanClass, name);
-    if (bean != null) {
-      return bean;
-    }
+  public <T> BeanEntry<T> candidate(Class<T> type, String name) {
+
+    // sort candiates by priority - Primary, Normal, Secondary
+    EntrySort<T> entrySort = new EntrySort<>();
+
+    entrySort.add(beans.candidate(type, name));
     for (BeanContext childContext : children.values()) {
-      bean = childContext.getBean(beanClass, name);
-      if (bean != null) {
-        return bean;
-      }
+      entrySort.add(childContext.candidate(type, name));
     }
-    return null;
+    return entrySort.get();
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  public <T> T getBean(Class<T> beanClass, String name) {
+
+    BeanEntry<T> candidate = candidate(beanClass, name);
+    return (candidate == null) ? null : candidate.getBean();
   }
 
   @Override
@@ -125,4 +131,49 @@ public void close() {
       }
     }
   }
+
+  private static class EntrySort<T> {
+
+    private BeanEntry<T> primary;
+    private int primaryCount;
+    private BeanEntry<T> secondary;
+    private int secondaryCount;
+    private BeanEntry<T> normal;
+    private int normalCount;
+
+    void add(BeanEntry<T> candidate) {
+
+      if (candidate != null) {
+        if (candidate.getPriority() == Flag.PRIMARY) {
+          primary = candidate;
+          primaryCount++;
+        } else if (candidate.getPriority() == Flag.SECONDARY) {
+          secondary = candidate;
+          secondaryCount++;
+        } else {
+          normal = candidate;
+          normalCount++;
+        }
+      }
+    }
+
+    BeanEntry<T> get() {
+      if (primaryCount > 1) {
+        throw new IllegalStateException("Multiple @Primary beans when only expecting one? Last was: " + primary);
+      }
+      if (primaryCount == 1) {
+        return primary;
+      }
+      if (normalCount > 1) {
+        throw new IllegalStateException("Multiple beans when only expecting one? Maybe use @Primary or @Secondary? Last was: " + normal);
+      }
+      if (normalCount == 1) {
+        return normal;
+      }
+      if (secondaryCount > 1) {
+        throw new IllegalStateException("Multiple @Secondary beans when only expecting one? Last was: " + primary);
+      }
+      return secondary;
+    }
+  }
 }

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

@@ -1,5 +1,7 @@
 package io.dinject.core;
 
+import io.dinject.BeanEntry;
+
 import javax.inject.Named;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -113,6 +115,19 @@ <T> T getBean(Class<T> type, String name) {
     return null;
   }
 
+  <T> BeanEntry<T> candidate(Class<T> type, String name) {
+
+    if (beans == null) {
+      // no beans in the root suppliedBeanMap
+      return null;
+    }
+    DContextEntry entry = beans.get(type.getCanonicalName());
+    if (entry != null) {
+      return entry.candidate(name);
+    }
+    return null;
+  }
+
   /**
    * Add all bean instances matching the given type to the list.
    */

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

@@ -1,5 +1,7 @@
 package io.dinject.core;
 
+import io.dinject.BeanEntry;
+
 import java.util.ArrayList;
 import java.util.List;
 
@@ -12,6 +14,21 @@ class DContextEntry {
 
   private final List<DContextEntryBean> entries = new ArrayList<>();
 
+  @SuppressWarnings("unchecked")
+  <T> BeanEntry<T> candidate(String name) {
+    if (entries.isEmpty()) {
+      return null;
+    }
+    if (entries.size() == 1) {
+      DContextEntryBean entry = entries.get(0);
+      return entry.candidate(name);
+    }
+
+    EntryMatcher matcher = new EntryMatcher(name);
+    matcher.match(entries);
+    return matcher.candidate();
+  }
+
   /**
    * Get a single bean given the name.
    */
@@ -96,10 +113,23 @@ Object getBean() {
       if (match == null) {
         return null;
       }
+      checkSecondary();
+      return match.getBean();
+    }
+
+    BeanEntry candidate() {
+      if (match == null) {
+        return null;
+      }
+      checkSecondary();
+      return match.getBeanEntry();
+    }
+
+    private void checkSecondary() {
       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

@@ -1,5 +1,7 @@
 package io.dinject.core;
 
+import io.dinject.BeanEntry;
+
 import javax.inject.Provider;
 import java.util.Objects;
 
@@ -64,6 +66,20 @@ boolean isSecondary() {
     return flag == Flag.SECONDARY;
   }
 
+  @SuppressWarnings("unchecked")
+  BeanEntry getBeanEntry() {
+    return new BeanEntry(flag, getBean(), name);
+  }
+
+  @SuppressWarnings("unchecked")
+  BeanEntry candidate(String name) {
+    if (name == null || Objects.equals(this.name, name)) {
+      return new BeanEntry(flag, obtainInstance(), name);
+    } else {
+      return null;
+    }
+  }
+
   /**
    * Provider based entry - get it once.
    */