Implemented @provide annotation

Author: Michal-python

dependencyInjection/src/main/java/cat/michal/catbase/injector/CatBaseInjector.java

@@ -4,6 +4,8 @@
 import cat.michal.catbase.injector.exceptions.InjectorException;
 
 import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.*;
 
@@ -27,6 +29,7 @@ public <T> T createInstance(Class<T> clazz) {
         if(clazz.isEnum()) {
             throw new InjectorException("Enums are not allowed");
         }
+
         if(clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers())) {
             List<? extends Class<? extends T>> implementations = classes.stream()
                     .filter(clazz::isAssignableFrom)
@@ -64,6 +67,16 @@ public List<Dependency<?>> getAll() {
         return Collections.unmodifiableList(dependencies);
     }
 
+
+    @SuppressWarnings("unchecked")
+    public <T> T provideInstance(Method method, Class<?> containingClass) {
+        try {
+            return (T) method.invoke(getInstance(containingClass), Arrays.stream(method.getParameterTypes()).map(this::getInstance).toArray());
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            throw new InjectorException("Error while invoking " + method, e);
+        }
+    }
+
     @Override
     public void registerInjectables() {
         classes.stream()
@@ -79,10 +92,21 @@ public void registerInjectables() {
                         return;
                     }
                     this.registerDependency(clazz);
+
+                    Arrays.stream(clazz.getMethods())
+                            .filter(method -> method.isAnnotationPresent(Provide.class))
+                            .forEach(method -> {
+                                if(method.getReturnType().isAnnotationPresent(Component.class)) {
+                                    throw new InjectorException("Provide methods annotated with @Component are not allowed");
+                                }
+                                registerDependency(method.getReturnType(), method, clazz);
+                            });
                 });
 
         //check for nested dependencies
-        dependencies.forEach(dependency -> Arrays.stream(dependency.getClazz().getDeclaredFields())
+        dependencies.stream()
+                .filter(dependency -> dependency.getProvideMethod() == null)
+                .forEach(dependency -> Arrays.stream(dependency.getClazz().getDeclaredFields())
                 .filter(field -> !field.isAnnotationPresent(Exclude.class))
                 .forEach(field -> {
                     Class<?> fieldType = field.getType();
@@ -103,11 +127,16 @@ public void registerInjectables() {
         List<Dependency<?>> sortedDependencies = new ArrayList<>();
         dependencies.forEach(dependency -> initializeDependency(dependency, sortedDependencies));
 
-
-
         //all dependencies initialized at this point
         sortedDependencies.forEach(dependency -> {
-            dependency.setInstance(createInstance(dependency.getClazz()));
+            Object instance;
+            if(dependency.getProvideMethod() == null || dependency.getContainingClass() == null) {
+                instance = createInstance(dependency.getClazz());
+            } else {
+                instance = provideInstance(dependency.getProvideMethod(), dependency.getContainingClass());
+            }
+
+            dependency.setInstance(instance);
             injectField(dependency.getInstance());
 
             Arrays.stream(dependency.getClazz().getMethods())
@@ -229,17 +258,23 @@ private <T> T instantiate(Dependency<T> dependency) {
         }
     }
 
-    private <T> void registerDependency(Class<T> clazz) {
+    private <T> void registerDependency(Class<T> clazz, Method provideMethod, Class<?> containingClass) {
         if(this.containsByClass(clazz)) {
             throw new InjectorException("Class " + clazz.getName() + " is already registered");
         }
         String injectableName = clazz.getAnnotation(Component.class) == null ? clazz.getSimpleName() : clazz.getAnnotation(Component.class).value();
         if(containsByName(injectableName)) {
             throw new InjectorException("Class with component name " + injectableName + " is already registered");
         }
-        Dependency<T> dependency = new Dependency<>(injectableName, clazz, null);
+        Dependency<T> dependency = new Dependency<>(injectableName, clazz, null, provideMethod, containingClass);
         this.dependencies.add(dependency);
     }
+
+
+    private <T> void registerDependency(Class<T> clazz) {
+        registerDependency(clazz, null, null);
+    }
+
     private <T> boolean containsByClass(Class<T> clazz) {
         return dependencies.stream().anyMatch(dependency -> dependency.getClazz().equals(clazz));
     }

dependencyInjection/src/main/java/cat/michal/catbase/injector/Dependency.java

@@ -1,5 +1,6 @@
 package cat.michal.catbase.injector;
 
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -18,18 +19,30 @@ public class Dependency<T> {
     private final Class<T> clazz;
     private final List<Dependency<?>> depends;
     private T instance;
+    private final Method provideMethod;
+    private final Class<?> containingClass;
 
-    public Dependency(String name, Class<T> clazz, T instance) {
+    public Dependency(String name, Class<T> clazz, T instance, Method provideMethod, Class<?> containingClass) {
         this.name = name;
         this.clazz = clazz;
         this.instance = instance;
+        this.provideMethod = provideMethod;
         this.depends = new ArrayList<>();
+        this.containingClass = containingClass;
     }
 
     public Class<?> getClazz() {
         return clazz;
     }
 
+    public Method getProvideMethod() {
+        return provideMethod;
+    }
+
+    public Class<?> getContainingClass() {
+        return containingClass;
+    }
+
     public <D> void addDependency(Dependency<D> dependency) {
         this.depends.add(dependency);
     }
@@ -50,4 +63,4 @@ public String getName() {
     public void setInstance(Object instance) {
         this.instance = (T) instance;
     }
-}
+}

dependencyInjection/src/main/java/cat/michal/catbase/injector/ProvideInjector.java

@@ -0,0 +1,5 @@
+package cat.michal.catbase.injector;
+
+public class ProvideInjector {
+
+}

dependencyInjection/src/main/java/cat/michal/catbase/injector/annotations/Provide.java

@@ -0,0 +1,11 @@
+package cat.michal.catbase.injector.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface Provide {
+}

dependencyInjection/src/test/java/cat/michal/catbase/injector/ProvideTest.java

@@ -0,0 +1,23 @@
+package cat.michal.catbase.injector;
+
+import cat.michal.catbase.injector.provideMock.WantedDependency;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+public class ProvideTest {
+    private CatBaseInjector injector;
+
+    @BeforeAll
+    void setup() {
+        this.injector = new CatBaseInjector("cat.michal.catbase.injector.provideMock");
+    }
+
+    @Test
+    void testProvide() {
+        Assertions.assertEquals("Desired Value!", this.injector.getInstance(WantedDependency.class).getField());
+    }
+
+}

dependencyInjection/src/test/java/cat/michal/catbase/injector/provideMock/NeededDependency.java

@@ -0,0 +1,8 @@
+package cat.michal.catbase.injector.provideMock;
+
+import cat.michal.catbase.injector.annotations.Component;
+
+@Component
+public class NeededDependency {
+    public String field = "Desired";
+}

dependencyInjection/src/test/java/cat/michal/catbase/injector/provideMock/Provider.java

@@ -0,0 +1,13 @@
+package cat.michal.catbase.injector.provideMock;
+
+import cat.michal.catbase.injector.annotations.Component;
+import cat.michal.catbase.injector.annotations.Provide;
+
+@Component
+public class Provider {
+
+    @Provide
+    public WantedDependency provide(NeededDependency depend) {
+        return new WantedDependency(depend.field + " Value!");
+    }
+}

dependencyInjection/src/test/java/cat/michal/catbase/injector/provideMock/WantedDependency.java

@@ -0,0 +1,13 @@
+package cat.michal.catbase.injector.provideMock;
+
+public class WantedDependency {
+    private final String field;
+
+    public WantedDependency(String field) {
+        this.field = field;
+    }
+
+    public String getField() {
+        return field;
+    }
+}