JavaDependencyInjection

src/main/java/mate.academy/Main.java

@@ -6,11 +6,9 @@
 import mate.academy.service.ProductService;
 
 public class Main {
-
     public static void main(String[] args) {
-        // Please test your Injector here. Feel free to push this class as a part of your solution
         Injector injector = Injector.getInjector();
-        ProductService productService = null;
+        ProductService productService = (ProductService) injector.getInstance(ProductService.class);
         List<Product> products = productService.getAllFromFile("products.txt");
         products.forEach(System.out::println);
     }

src/main/java/mate.academy/lib/Component.java

@@ -1,5 +1,8 @@
 package mate.academy.lib;
 
-public @interface Component {
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
 
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Component {
 }

src/main/java/mate.academy/lib/Inject.java

@@ -1,5 +1,8 @@
 package mate.academy.lib;
 
-public @interface Inject {
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
 
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Inject {
 }

src/main/java/mate.academy/lib/Injector.java

@@ -1,13 +1,61 @@
 package mate.academy.lib;
 
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Map;
+
 public class Injector {
     private static final Injector injector = new Injector();
+    private final Map<Class<?>, Object> instances = new HashMap<>();
 
     public static Injector getInjector() {
         return injector;
     }
 
     public Object getInstance(Class<?> interfaceClazz) {
-        return null;
+        if (!interfaceClazz.isInterface()) {
+            throw new RuntimeException("Only interfaces are supported");
+        }
+
+        Class<?> implClass = findImplementation(interfaceClazz);
+        if (implClass == null || !implClass.isAnnotationPresent(Component.class)) {
+            throw new RuntimeException("No implementation found for " + interfaceClazz.getName());
+        }
+
+        return createInstance(implClass);
+    }
+
+    private Class<?> findImplementation(Class<?> interfaceClazz) {
+        // This method should return the implementation class for the given interface
+        // For simplicity, let's assume we have a hardcoded map of implementations
+        Map<Class<?>, Class<?>> implementations = Map.of(
+            ProductService.class, ProductServiceImpl.class,
+            ProductParser.class, ProductParserImpl.class,
+            FileReaderService.class, FileReaderServiceImpl.class
+        );
+        return implementations.get(interfaceClazz);
+    }
+
+    private Object createInstance(Class<?> implClass) {
+        if (instances.containsKey(implClass)) {
+            return instances.get(implClass);
+        }
+
+        try {
+            Object instance = implClass.getDeclaredConstructor().newInstance();
+            instances.put(implClass, instance);
+
+            for (Field field : implClass.getDeclaredFields()) {
+                if (field.isAnnotationPresent(Inject.class)) {
+                    field.setAccessible(true);
+                    Object fieldInstance = getInstance(field.getType());
+                    field.set(instance, fieldInstance);
+                }
+            }
+
+            return instance;
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException("Failed to create instance of " + implClass.getName(), e);
+        }
     }
 }