Sopilnyak container

OWNER.md

@@ -0,0 +1,2 @@
+## Разработка на Java
+### Сопильняк Ольга, СА-11

src/main/java/track/container/Container.java

@@ -1,41 +1,133 @@
 package track.container;
 
+import java.beans.PropertyEditor;
+import java.beans.PropertyEditorManager;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import track.container.config.Bean;
+import track.container.config.Property;
+import track.container.config.InvalidConfigurationException;
 
 /**
  * Основной класс контейнера
  * У него определено 2 публичных метода, можете дописывать свои методы и конструкторы
  */
 public class Container {
 
-    Map<String, Object> map = new HashMap<>();
+    private Map<String, Bean> beansById = new HashMap<>();
+    private Map<String, Bean> beansByClassName = new HashMap<>();
+    private Map<Bean, Object> objectByBean = new HashMap<>();
+
 
     // Реализуйте этот конструктор, используется в тестах!
     public Container(List<Bean> beans) throws Exception {
+        for (Bean bean: beans) {
+            this.beansById.put(bean.getId(), bean);
+            this.beansByClassName.put(bean.getClassName(), bean);
+        }
+
+    }
+
+    public Container(String configFileName) throws
+            InvalidConfigurationException, Exception {
+
+        this((new JsonConfigReader()).parseBeans(
+                new File(Main.class.getClassLoader()
+                .getResource(configFileName)
+                        .getFile())
+        ));
+    }
+
+    private String getSetMethodName(String fieldName) {
+        return "set" +
+                Character.toUpperCase(fieldName.charAt(0)) +
+                fieldName.substring(1);
+    }
+
+    private void createObject(Bean bean) throws ClassNotFoundException,
+            IllegalAccessException, InstantiationException, NoSuchFieldException,
+            NoSuchMethodException, InvocationTargetException {
+
+        Class currentClass = Class.forName(bean.getClassName());
+        Object object = currentClass.newInstance();
+        objectByBean.put(bean, object);
 
+        for (Property property: bean.getProperties().values()) {
+            Field field = currentClass.getDeclaredField(property.getName());
+            Class type = field.getType();
+            Method set = currentClass.getMethod(
+                    getSetMethodName(
+                            property.getName()), type
+            );
+
+            switch (property.getType()) {
+                case VAL:
+                    PropertyEditor editor = PropertyEditorManager.findEditor(type);
+                    editor.setAsText(property.getValue());
+                    set.invoke(object, editor.getValue());
+                    break;
+
+                case REF:
+                    if (!objectByBean.containsKey(
+                            beansById.get(property.getValue())
+                    )) {
+                        createObject(beansById.get(property.getValue()));
+                    }
+                    set.invoke(object, objectByBean.get(
+                            beansById.get(property.getValue())
+                    ));
+                    break;
+
+                default:
+                    break;
+            }
+        }
     }
 
-    public static void main(String[] args) throws Exception {
+    private Object getByBean(Bean bean) throws ClassNotFoundException,
+            InstantiationException, IllegalAccessException, NoSuchMethodException,
+            NoSuchFieldException, InvocationTargetException {
 
+        if (bean != null) {
+
+            if (!objectByBean.containsKey(bean)) {
+                createObject(bean);
+            }
+
+            return objectByBean.get(bean);
+        }
+        return null;
     }
 
+
     /**
      *  Вернуть объект по имени бина из конфига
      *  Например, Car car = (Car) container.getById("carBean")
      */
-    public Object getById(String id) {
-        return null;
+    public Object getById(String id) throws ClassNotFoundException,
+            IllegalAccessException, InstantiationException,
+            NoSuchMethodException, NoSuchFieldException,
+            InvocationTargetException {
+
+        return getByBean(beansById.get(id));
     }
 
     /**
      * Вернуть объект по имени класса
      * Например, Car car = (Car) container.getByClass("track.container.beans.Car")
      */
-    public Object getByClass(String className) {
-        return null;
+    public Object getByClass(String className)  throws ClassNotFoundException,
+            IllegalAccessException, InstantiationException,
+            NoSuchMethodException, NoSuchFieldException,
+            InvocationTargetException {
+
+        return getByBean(beansByClassName.get(className));
     }
 }

src/main/java/track/container/JsonConfigReader.java

@@ -1,19 +1,98 @@
 package track.container;
 
 import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
+import track.container.config.*;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import track.container.config.Bean;
 import track.container.config.ConfigReader;
 import track.container.config.InvalidConfigurationException;
 
-/**
- * TODO: Реализовать
- */
+
 public class JsonConfigReader implements ConfigReader {
 
     @Override
     public List<Bean> parseBeans(File configFile) throws InvalidConfigurationException {
-        return null;
+
+        ObjectMapper objectMapper = new ObjectMapper();
+        JsonNode rootNode;
+
+        try {
+            rootNode = objectMapper.readTree(configFile);
+        } catch (IOException e) {
+            throw new InvalidConfigurationException("File not found");
+        }
+
+        if (!rootNode.has("beans")) {
+            throw new InvalidConfigurationException("No \"beans\", field");
+        }
+
+        List<Bean> beanList = new ArrayList();
+
+        for (JsonNode bean: rootNode.get("beans")) {
+            beanList.add(parseBean(bean));
+        }
+
+        return beanList;
+    }
+
+    private Property parseProperty(JsonNode property) throws InvalidConfigurationException {
+
+        if (!property.has("name")) {
+            throw new InvalidConfigurationException("No \"name\" field");
+        }
+
+        if (!(property.has("type"))) {
+            throw new InvalidConfigurationException("No \"type\" field");
+        }
+
+        if (!(property.has("value"))) {
+            throw new InvalidConfigurationException("No \"type\" field");
+        }
+
+        String name = property.get("name").asText();
+
+        ValueType type;
+        String value = property.get("value").asText();
+
+        if (property.get("type").asText().equals("REF")) {
+            type = ValueType.REF;
+        } else {
+            type = ValueType.VAL;
+        }
+
+        return new Property(name, value, type);
+    }
+
+    private Bean parseBean(JsonNode bean) throws InvalidConfigurationException {
+        if (!bean.has("id")) {
+            throw new InvalidConfigurationException("No \"id\" field");
+        }
+
+        if (!bean.has("className")) {
+            throw new InvalidConfigurationException("No \"className\" field");
+        }
+
+        if (!bean.has("properties")) {
+            throw new InvalidConfigurationException("No \"properties\" field");
+        }
+
+        String id = bean.get("id").asText();
+        String className = bean.get("className").asText();
+        Map<String, Property> properties = new HashMap();
+
+        for (JsonNode property: bean.get("properties")) {
+            Property parsedProperty = parseProperty(property);
+            properties.put(parsedProperty.getName(), parsedProperty);
+        }
+
+        return new Bean(id, className, properties);
     }
 }

src/main/java/track/container/Main.java

@@ -1,5 +1,11 @@
 package track.container;
 
+import track.container.beans.Car;
+import track.container.config.Bean;
+import track.container.config.ConfigReader;
+
+import java.util.List;
+
 /**
  *
  */
@@ -13,14 +19,16 @@ public static void main(String[] args) {
 
          */
 
-//        // При чтении нужно обработать исключение
-//        ConfigReader reader = new JsonReader();
-//        List<Bean> beans = reader.parseBeans("config.json");
-//        Container container = new Container(beans);
-//
-//        Car car = (Car) container.getByClass("track.container.beans.Car");
-//        car = (Car) container.getById("carBean");
-
-
+        // При чтении нужно обработать исключение
+        try {
+            // ConfigReader reader = new JsonConfigReader();
+            // List<Bean> beans = reader.parseBeans("config.json");
+            Container container = new Container("config.json");
+
+            Car car = (Car) container.getByClass("track.container.beans.Car");
+            car = (Car) container.getById("carBean");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
     }
 }

src/main/java/track/lessons/l7threads/future/Main.java

@@ -15,7 +15,7 @@
  */
 public class Main {
 
-    static Logger log = LoggerFactory.getLogger(Main.class);
+    /* static Logger log = LoggerFactory.getLogger(Main.class);
 
     public static void main(String[] args) throws Exception {
         Transformer<Image> transformer = new Transformer<>();
@@ -45,6 +45,6 @@ public static ImageInfo store(Image image) {
             log.info("Store finished.");
             return image.getImageInfo();
         }
-    }
+    } */
 
 }

src/main/java/track/lessons/lesson5generics/Cypher.java

@@ -1,16 +1,13 @@
 package track.lessons.lesson5generics;
 
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 import track.util.Util;
 
 /**
  *
  */
+
 public class Cypher {
 
     public static final int SYMBOL_DIST = 32;
@@ -25,30 +22,45 @@ private Map<Character, Integer> readData(String data) {
                 }
                 // Если это буква, то собираем частотную информацию
 
-
+                if (map.containsKey(ch)) {
+                    map.put(ch, map.get(ch) + 1);
+                } else {
+                    map.put(ch, 1);
+                }
 
             }
         }
         return map;
     }
 
     /**
-    На вход приходит текст
-    1. Считываем readData() и получаем мапу {Символ -> Кол-во употреблений}
-    2. Далее нам нужно отсортировать пары ключ-значение по значению
+     На вход приходит текст
+     1. Считываем readData() и получаем мапу {Символ -> Кол-во употреблений}
+     2. Далее нам нужно отсортировать пары ключ-значение по значению
      (Называются{@code List<Map.Entry<Character, Integer>>})
      (то есть по частоте употребления). Для этого можно создать список этих пар и отсортировать список.
      У java.lang.List есть вспомогательный метод {@link List#sort(Comparator)}
      Где Comparator - это логика сравнения объектов.
 
      3. После того, как получен отсортированный список {@code List<Map.Entry<Character, Integer>>} нужно превратить его
-        обратно в Map для того, чтобы иметь быстрый доступ get().
+     обратно в Map для того, чтобы иметь быстрый доступ get().
 
      */
+
     public Map<Character, Integer> buildHist(String data) {
         Map<Character, Integer> map = readData(data);
-
-        return null;
+        List<Map.Entry<Character, Integer>> list = new ArrayList<>(map.entrySet());
+        list.sort(new Comparator<Map.Entry<Character, Integer>>() {
+            @Override
+            public int compare(Map.Entry<Character, Integer> o1, Map.Entry<Character, Integer> o2) {
+                return o2.getValue().compareTo(o1.getValue());
+            }
+        });
+        Map<Character, Integer> sorted = new LinkedHashMap<>();
+        for (Map.Entry<Character, Integer> i : list) {
+            sorted.put(i.getKey(), i.getValue());
+        }
+        return sorted;
     }
 
     /**
@@ -60,7 +72,14 @@ public Map<Character, Integer> buildHist(String data) {
      * @return расшифрованный текст
      */
     public String merge(List<Character> in, List<Character> out, String encrypted) {
-        return null;
+        String newString = "";
+        for (int i = 0; i < encrypted.length(); i++) {
+            if (out.indexOf(encrypted.charAt(i)) > 0 &&
+                    out.indexOf(encrypted.charAt(i)) < in.size()) {
+                newString += in.get(out.indexOf(encrypted.charAt(i)));
+            }
+        }
+        return newString;
     }
 
     public static void main(String[] args) {
@@ -70,6 +89,7 @@ public static void main(String[] args) {
 
         String encryptedText = Util.encrypt(Util.readFile("toEncrypt.txt"));
         Map<Character, Integer> encryptedHist = cypher.buildHist(encryptedText);
+        System.out.println(Util.readFile("toEncrypt.txt"));
 
         String result = cypher.merge(
                 new LinkedList<>(dataHist.keySet()),