Jv dependency injection solution

pom.xml

@@ -10,7 +10,7 @@
 
 
     <properties>
-        <jdk.version>11</jdk.version>
+        <jdk.version>17</jdk.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <maven.checkstyle.plugin.version>3.1.1</maven.checkstyle.plugin.version>

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

@@ -10,7 +10,7 @@ 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,11 @@
 package mate.academy.lib;
 
-public @interface Component {
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
 
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Component {
 }

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

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

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

@@ -1,13 +1,139 @@
 package mate.academy.lib;
 
+import java.io.File;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
 public class Injector {
     private static final Injector injector = new Injector();
+    private static final Map<Class<?>, Class<?>> interfacesImplementations;
+    private static final Map<Class<?>, Object> instances = new HashMap<>();
+    private static final String SERVICE_PACKAGE = "mate.academy.service";
+    private static final String SERVICE_PACKAGE_IMPL = "mate.academy.service.impl";
+    private static final String CLASS_INDICATOR = ".class";
+
+    static {
+        interfacesImplementations = interfacesImplementationsConfiguration();
+    }
 
     public static Injector getInjector() {
         return injector;
     }
 
     public Object getInstance(Class<?> interfaceClazz) {
-        return null;
+        Object clazzImplementationInstance = null;
+        Class<?> clazz = findImplementation(interfaceClazz);
+        Field[] fields = clazz.getDeclaredFields();
+        for (Field field : fields) {
+            if (field.isAnnotationPresent(Inject.class)) {
+                Object fieldInstance = getInstance(field.getType());
+                clazzImplementationInstance = createNewInstance(clazz);
+                field.setAccessible(true);
+                try {
+                    field.set(clazzImplementationInstance, fieldInstance);
+                } catch (IllegalAccessException e) {
+                    throw new RuntimeException("Can't initialize field value. Class: "
+                            + clazz.getName() + ", field: " + field.getName());
+                }
+            }
+        }
+        if (clazzImplementationInstance == null) {
+            clazzImplementationInstance = createNewInstance(clazz);
+        }
+        return clazzImplementationInstance;
+    }
+
+    private static Object createNewInstance(Class<?> clazz) {
+        if (instances.containsKey(clazz)) {
+            return instances.get(clazz);
+        }
+        try {
+            Constructor<?> constructor = clazz.getConstructor();
+            Object instance = constructor.newInstance();
+            instances.put(clazz, instance);
+            return instance;
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException("Can't create new instance of class - " + clazz.getName());
+        }
+    }
+
+    private static Class<?> findImplementation(Class<?> interfaceClazz) {
+        if (interfaceClazz.isInterface()) {
+            if (!interfacesImplementations.containsKey(interfaceClazz)) {
+                throw new RuntimeException("Can`t find interface " + interfaceClazz.getName());
+            }
+            Class<?> implementation = interfacesImplementations.get(interfaceClazz);
+            if (implementation == null) {
+                throw new RuntimeException("Interface " + interfaceClazz.getName()
+                        + " has no implementations or they doesn't annotated by @Component");
+            }
+            return implementation;
+        }
+        componentCheck(interfaceClazz);
+        return interfaceClazz;
+    }
+
+    private static Map<Class<?>, Class<?>> interfacesImplementationsConfiguration() {
+        Map<Class<?>, Class<?>> interfacesImplementations = new HashMap<>();
+        for (Class<?> clazzInterface : findServiceInterfaces()) {
+            Class<?> interfaceImplementation = null;
+            for (Class<?> clazzImplementation : findComponents()) {
+                if (clazzInterface.isAssignableFrom(clazzImplementation)) {
+                    interfaceImplementation = clazzImplementation;
+                    break;
+                }
+            }
+            System.out.println(clazzInterface + " " + interfaceImplementation);
+            interfacesImplementations.put(clazzInterface, interfaceImplementation);
+        }
+        return interfacesImplementations;
+    }
+
+    private static List<Class<?>> findComponents() {
+        return findClassesByPackage(SERVICE_PACKAGE_IMPL).stream()
+                .filter(clazz -> clazz.isAnnotationPresent(Component.class))
+                .toList();
+    }
+
+    private static List<Class<?>> findServiceInterfaces() {
+        return findClassesByPackage(SERVICE_PACKAGE).stream()
+                .filter(Class::isInterface)
+                .toList();
+    }
+
+    public static List<Class<?>> findClassesByPackage(String packageName) {
+        String path = packageName.replace('.', '/');
+        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+        File packageDirectory = new File(classLoader.getResource(path).getFile());
+        File[] files = packageDirectory.listFiles();
+        return Arrays.stream(files)
+                .filter(File::isFile)
+                .filter(file -> file.getName().endsWith(CLASS_INDICATOR))
+                .map(file -> getClass(file.getName(), packageName))
+                .collect(Collectors.toList());
+    }
+
+    private static Class<?> getClass(String className, String packageName) {
+        try {
+            String clearedClassName = className.substring(0,
+                    className.length() - CLASS_INDICATOR.length());
+            return Class.forName(packageName + "." + clearedClassName);
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException("Can't find class " + className);
+        }
+    }
+
+    private static void componentCheck(Class<?> clazz) {
+        if (!clazz.isAnnotationPresent(Component.class)) {
+            throw new RuntimeException("Unsupported class " + clazz
+                    + ", should be annotated by @Component");
+        }
+
     }
 }
+

src/main/java/mate.academy/service/impl/FileReaderServiceImpl.java

@@ -4,8 +4,10 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.util.List;
+import mate.academy.lib.Component;
 import mate.academy.service.FileReaderService;
 
+@Component
 public class FileReaderServiceImpl implements FileReaderService {
     @Override
     public List<String> readFile(String fileName) {

src/main/java/mate.academy/service/impl/ProductParserImpl.java

@@ -1,9 +1,11 @@
 package mate.academy.service.impl;
 
 import java.math.BigDecimal;
+import mate.academy.lib.Component;
 import mate.academy.model.Product;
 import mate.academy.service.ProductParser;
 
+@Component
 public class ProductParserImpl implements ProductParser {
     public static final int ID_POSITION = 0;
     public static final int NAME_POSITION = 1;

src/main/java/mate.academy/service/impl/ProductServiceImpl.java

@@ -2,13 +2,18 @@
 
 import java.util.List;
 import java.util.stream.Collectors;
+import mate.academy.lib.Component;
+import mate.academy.lib.Inject;
 import mate.academy.model.Product;
 import mate.academy.service.FileReaderService;
 import mate.academy.service.ProductParser;
 import mate.academy.service.ProductService;
 
+@Component
 public class ProductServiceImpl implements ProductService {
+    @Inject
     private ProductParser productParser;
+    @Inject
     private FileReaderService fileReaderService;
 
     @Override