SdkComponent: Add optional qualifier field

This qualifier enables having several components implementations for the
same SDK version and with the same component type. You can choose the
one you want by indicating its qualifier.

The qualifier defaults to the empty string, so this is backwards
compatible for existing code. The behaviour will be the same if you don't
have components with the same version and type. but if you do an
exception will be thrown instead of returning arbitrarily one of the
component implementation.

Update and add unit tests to check the expected behaviour.

Author: bertrand-lorentz

src/main/java/eu/europa/ted/eforms/sdk/component/SdkComponent.java

@@ -13,4 +13,6 @@
   public String[] versions();
 
   public SdkComponentType componentType();
+
+  public String qualifier() default "";
 }

src/main/java/eu/europa/ted/eforms/sdk/component/SdkComponentDescriptor.java

@@ -23,12 +23,20 @@ public class SdkComponentDescriptor<T> implements Serializable {
 
   private SdkComponentType componentType;
 
+  private String qualifier;
+
   private Class<T> implType;
 
   public SdkComponentDescriptor(String sdkVersion, SdkComponentType componentType,
       Class<T> implType) {
+    this(sdkVersion, componentType, "", implType);
+  }
+
+  public SdkComponentDescriptor(String sdkVersion, SdkComponentType componentType, String qualifier,
+      Class<T> implType) {
     this.sdkVersion = Validate.notBlank(sdkVersion, "Undefined SDK version");
     this.componentType = Validate.notNull(componentType, "Undefined component type");
+    this.qualifier = Validate.notNull(qualifier, "Undefined qualifier");
     this.implType = Validate.notNull(implType, "Undefined implementation type");
   }
 
@@ -94,7 +102,7 @@ private boolean constructorHasExpectedParameters(Constructor<?> constructor,
 
   @Override
   public int hashCode() {
-    return Objects.hash(sdkVersion, componentType, implType);
+    return Objects.hash(componentType, sdkVersion, qualifier, implType);
   }
 
   @Override
@@ -106,8 +114,9 @@ public boolean equals(Object obj) {
     if (getClass() != obj.getClass())
       return false;
     SdkComponentDescriptor<?> other = (SdkComponentDescriptor<?>) obj;
-    return componentType == other.componentType
+    return componentType == other.componentType 
         && Objects.equals(sdkVersion, other.sdkVersion)
+        && Objects.equals(qualifier, other.qualifier)
         && Objects.equals(implType, other.implType);
   }
 

src/main/java/eu/europa/ted/eforms/sdk/component/SdkComponentFactory.java

@@ -3,9 +3,9 @@
 import java.text.MessageFormat;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.Stream;
 import org.reflections.Reflections;
@@ -20,7 +20,40 @@
 public abstract class SdkComponentFactory {
   private static final Logger logger = LoggerFactory.getLogger(SdkComponentFactory.class);
 
-  private Map<String, Map<SdkComponentType, SdkComponentDescriptor<?>>> componentsMap;
+  private Map<String, Map<ComponentSelector, SdkComponentDescriptor<?>>> componentsMap;
+
+  class ComponentSelector {
+    private final SdkComponentType componentType;
+    private final String qualifier;
+
+    public ComponentSelector(SdkComponentType componentType, String qualifier) {
+      this.componentType = componentType;
+      this.qualifier = qualifier;
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(componentType, qualifier);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (this == obj)
+        return true;
+      if (obj == null)
+        return false;
+      if (getClass() != obj.getClass())
+        return false;
+      ComponentSelector other = (ComponentSelector) obj;
+      if (!getEnclosingInstance().equals(other.getEnclosingInstance()))
+        return false;
+      return componentType == other.componentType && Objects.equals(qualifier, other.qualifier);
+    }
+
+    private SdkComponentFactory getEnclosingInstance() {
+      return SdkComponentFactory.this;
+    }
+  }
 
   protected SdkComponentFactory() {
     populateComponents();
@@ -54,6 +87,8 @@ private void populateComponents() {
 
           String[] supportedSdkVersions = annotation.versions();
           SdkComponentType componentType = annotation.componentType();
+          String qualifier = annotation.qualifier();
+          ComponentSelector selector = new ComponentSelector(componentType, qualifier);
 
           logger.trace("Class [{}] has a component type of [{}] and supports SDK versions [{}]",
               clazz, componentType, supportedSdkVersions);
@@ -62,11 +97,11 @@ private void populateComponents() {
             SdkComponentDescriptor<?> component =
                 new SdkComponentDescriptor<>(sdkVersion, componentType, clazz);
 
-            Map<SdkComponentType, SdkComponentDescriptor<?>> components =
+            Map<ComponentSelector, SdkComponentDescriptor<?>> components =
                 componentsMap.get(sdkVersion);
 
             if (components != null) {
-              SdkComponentDescriptor<?> existingComponent = components.get(componentType);
+              SdkComponentDescriptor<?> existingComponent = components.get(selector);
 
               if (existingComponent != null && !existingComponent.equals(component)) {
                 throw new IllegalArgumentException(MessageFormat.format(
@@ -75,30 +110,39 @@ private void populateComponents() {
                     clazz.getName()));
               }
             } else {
-              components = new EnumMap<>(SdkComponentType.class);
+              components = new HashMap<>();
               componentsMap.put(sdkVersion, components);
             }
 
-            components.put(componentType, component);
+            components.put(selector, component);
           });
         });
   }
 
   protected <T> T getComponentImpl(String sdkVersion, final SdkComponentType componentType,
       final Class<T> intf, Object... initArgs) throws InstantiationException {
 
+    return getComponentImpl(sdkVersion, componentType, "", intf, initArgs);
+  }
+
+  protected <T> T getComponentImpl(String sdkVersion, final SdkComponentType componentType,
+      final String qualifier, final Class<T> intf, Object... initArgs) throws InstantiationException {
+
     String normalizedVersion = normalizeVersion(sdkVersion);
 
+    ComponentSelector selector = new ComponentSelector(componentType, qualifier);
+
     @SuppressWarnings("unchecked")
     SdkComponentDescriptor<T> descriptor =
         (SdkComponentDescriptor<T>) Optional.ofNullable(componentsMap.get(normalizedVersion))
-            .orElseGet(Collections::emptyMap).get(componentType);
+            .orElseGet(Collections::emptyMap).get(selector);
 
     if (descriptor == null) {
       logger.error("Failed to load required components of SDK [{}]", sdkVersion);
       throw new IllegalArgumentException(
-          MessageFormat.format("No implementation found for component type [{0}] of SDK [{1}].",
-              componentType, sdkVersion));
+          MessageFormat.format(
+              "No implementation found for SDK [{0}], component type [{1}] and qualifier '{2}'.",
+              sdkVersion, componentType, qualifier));
     }
 
     return descriptor.createInstance(initArgs);

src/test/java/eu/europa/ted/eforms/sdk/component/MyComponentFactory.java

@@ -7,4 +7,10 @@ protected <T> T getComponentImpl(String sdkVersion, SdkComponentType componentTy
       Object... initArgs) throws InstantiationException {
     return super.getComponentImpl(sdkVersion, componentType, intf, initArgs);
   }
+
+  @Override
+  protected <T> T getComponentImpl(String sdkVersion, SdkComponentType componentType,
+      String qualifier, Class<T> intf, Object... initArgs) throws InstantiationException {
+    return super.getComponentImpl(sdkVersion, componentType, qualifier, intf, initArgs);
+  }
 }

src/test/java/eu/europa/ted/eforms/sdk/component/NodeComponentWithQualifier.java

@@ -0,0 +1,10 @@
+package eu.europa.ted.eforms.sdk.component;
+
+@SdkComponent(versions = "1", componentType = SdkComponentType.NODE, qualifier = "qualifier")
+public class NodeComponentWithQualifier implements TestComponent {
+
+  @Override
+  public String testMethod() {
+    return "Node";
+  }
+}

src/test/java/eu/europa/ted/eforms/sdk/component/ScriptGeneratorB.java

@@ -1,6 +1,6 @@
 package eu.europa.ted.eforms.sdk.component;
 
-@SdkComponent(versions = "1", componentType = SdkComponentType.SCRIPT_GENERATOR)
+@SdkComponent(versions = "1", componentType = SdkComponentType.SCRIPT_GENERATOR, qualifier = "B")
 class ScriptGeneratorB implements TestComponent {
 
   @Override

src/test/java/eu/europa/ted/eforms/sdk/component/ScriptGeneratorSubclass.java

@@ -1,5 +1,6 @@
 package eu.europa.ted.eforms.sdk.component;
 
+@SdkComponent(versions = "1", componentType = SdkComponentType.SCRIPT_GENERATOR, qualifier = "other")
 class ScriptGeneratorSubclass extends ScriptGeneratorA {
 
   @Override

src/test/java/eu/europa/ted/eforms/sdk/component/SdkComponentFactoryTest.java

@@ -1,6 +1,8 @@
 package eu.europa.ted.eforms.sdk.component;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 import org.junit.jupiter.api.Test;
 
 class SdkComponentFactoryTest {
@@ -16,12 +18,44 @@ void testGetComponentImpl() throws InstantiationException {
   @Test
   void testMultipleComponentImpl() throws InstantiationException {
     MyComponentFactory factory = new MyComponentFactory();
-    TestComponent impl =
+
+    TestComponent implNoQualifier =
         factory.getComponentImpl("1.0", SdkComponentType.SCRIPT_GENERATOR, TestComponent.class);
 
-    // impl could be either ScriptGeneratorA, ScriptGeneratorB, or ScriptGeneratorSubclass
-    // depending on which was the last found in SdkComponentFactory.populateComponents()
-    assertEquals(ScriptGeneratorSubclass.class, impl.getClass());
-    assertEquals("Subclass", impl.testMethod());
+    // No qualifier specified, so we get an instance of ScriptGeneratorA
+    assertEquals(ScriptGeneratorA.class, implNoQualifier.getClass());
+    assertEquals("A", implNoQualifier.testMethod());
+
+    TestComponent implQualifierOther =
+        factory.getComponentImpl("1.0", SdkComponentType.SCRIPT_GENERATOR, "other", TestComponent.class);
+
+    // Qualifier is "other", so we get an instance of ScriptGeneratorSubclass
+    assertEquals(ScriptGeneratorSubclass.class, implQualifierOther.getClass());
+    assertEquals("Subclass", implQualifierOther.testMethod());
+  }
+
+  @Test
+  void testComponentNotFound() throws InstantiationException {
+    MyComponentFactory factory = new MyComponentFactory();
+
+    // No component for this version
+    assertThrows(IllegalArgumentException.class, () ->
+        factory.getComponentImpl("2.0", SdkComponentType.SCRIPT_GENERATOR, TestComponent.class));
+
+    // No component for this type
+    assertThrows(IllegalArgumentException.class, () ->
+        factory.getComponentImpl("1.0", SdkComponentType.CODELIST, TestComponent.class));
+
+    // No component for this qualifier
+    assertThrows(IllegalArgumentException.class, () ->
+        factory.getComponentImpl("1.0", SdkComponentType.SCRIPT_GENERATOR, "BAD", TestComponent.class));
+
+    // Only component for this version and type does not have a qualifier
+    assertThrows(IllegalArgumentException.class, () ->
+    factory.getComponentImpl("0.5", SdkComponentType.EFX_EXPRESSION_TRANSLATOR, "BAD", TestComponent.class));
+
+    // Only component for this version and type has a qualifier
+    assertThrows(IllegalArgumentException.class, () ->
+    factory.getComponentImpl("1.0", SdkComponentType.NODE, TestComponent.class));
   }
 }