XML(eXtensible Markup Language) - расширяемый язык разметки документов. В отличие от HTML, который направлен на визуальное представление документа в браузере, XML используется для обмена данными между компьютером и приложением.

Внутри, файл выглядит, как набор тегов с информацией(открывающие и закрывающие) в виде древовидной структуры.
Рассмотрим пример ниже. В каждом файле существует корневой тег - в нашем случае <voters> (он может иметь любое имя, в зависимости от выполняемой задачи). Далее, идут ветви, их может быть несколько, в нашем случае они одного типа с тегом voter и visit. И внутри мы имеем атрибуты {name, birthDay, station, time} с их значениями.

<?xml version="1.0" encoding="UTF-8"?>
<voters>
<voter name="Тиронов Мартьян" birthDay="1932.11.08">   
<visit station="120" time="2015.09.17 15:51:40" />
</voter>
<voter name="Варик Макар" birthDay="1924.12.31">   
<visit station="48" time="2015.09.21 22:24:28" />
</voter>
<voter name="Погребной Миронег" birthDay="1948.05.23">   
<visit station="170" time="2015.09.19 14:59:01" />
</voter>
...
...
</voters>

Далее, на основе XML нам нужно создать объектную модель. Для этого создается пакет model и в нем создается класс, с таким именем, как и в XML файле.
Класс создается для добавления и дальнейшей работы с элементами, которые находятся в XML файле.

Существуют несколько стратегий обработки XML документов. Мы
рассмотрим - DOM (Document Object Model) и SAX (Simple API for XML). Основное их отличие связано с тем, что использование DOM позволяет читать и вносить изменения в существующий XML-документ, а также создавать новый. Стратегия использования SAX основывается на том, что содержимое XML-документа только анализируется. XML-текст может быть больших размеров: DOM должен весь документ «заглотить» и проанализировать, а SAX-парсер обрабатывает XML-документ последовательно и не требует дополнительной памяти.

DOM API
DOM (Document Object Model) - это стандартный способ представления и взаимодействия с содержимым XML-документов в программах на Java. Предоставляет процесс обработки по факту, загружая файл полностью в память. Хорошо работает с небольшими файлами.

Для парсинга, нам следует открыть файл, используя объекты типа - File, DocumentBuilderFactory, DocumentBuilder, Document.
В DOM есть три важных объекта - Node(каждый элемент(отступы, строки и тд) в XML), NodeList(получаем лист наших Node), Element(конкретный объект, заключаемый в тег).

SAX API
SAX(Simple API for XML) - это API, который используется для чтения и обработки XML-документов в Java. Он очень быстр и мало зависит от объема данных, за счет этого имеет большую популярность.
Чтение XML документа с помощью SAX является событийном процессом, то есть SAX предоставляет набор обработчиков событий, которые вызываются автоматически при обработке каждого элемента документа. Файл в память подгружается частями.

Для парсинга мы используем объекты типа - SAXParserFactory(Определяет API фабрики, который позволяет приложениям сконфигурировать и получить SAX базируемый синтаксический анализатор, чтобы проанализировать XML-документы), SAXParser. И для успешной работы парсера нам необходимо переопределить нужные нам методы класса DefaultHandler.

Полезные ссылки:
https://www.youtube.com/watch?v=wXupOedG6vU
https://www.youtube.com/watch?v=T0nRDi0k4fU
https://java-online.ru/java-xml.xhtml
https://habr.com/ru/articles/62757/
https://mou43-samara.ru/education/kak-prochitat-xml-fajl-v-java-prostye-shagi-i#:~:text=i%20%3C%20attributes.getLength-,%D0%A7%D1%82%D0%BE%20%D1%82%D0%B0%D0%BA%D0%BE%D0%B5%20xml%20%D1%84%D0%B0%D0%B9%D0%BB%20%D0%B8%20%D0%B7%D0%B0%D1%87%D0%B5%D0%BC%20%D0%BE%D0%BD%20%D0%BD%D1%83%D0%B6%D0%B5%D0%BD%20%D0%B2%20Java,%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D0%BC%D0%B8%20%D0%BC%D0%B5%D0%B6%D0%B4%D1%83%20%D0%BA%D0%BE%D0%BC%D0%BF%D1%8C%D1%8E%D1%82%D0%B5%D1%80%D0%B0%D0%BC%D0%B8%20%D0%B8%20%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F%D0%BC%D0%B8.

Десериализация - это процесс обратного преобразования потока данных байтового типа в объект в памяти.

Существует три способа выполнения сериализации {Используя протокол по умолчанию, Изменяя протокол по умолчанию, Создавая собственный протокол}.
В данной статье рассмотрим первый способ.

Для того, чтобы отметить наш объект, как сериализумый, мы должны реализовать интерфейс java.io.Serializable, что и будет являться для API знаком того, что объект может быть разложен на байты и затем вновь восстановлен.
Интерфейс Serializable является лишь маркерным интерфейсом и позволяет механизму сериализации определить возможность сохранения данного класса.

Класс, на котором будем демонстрировать примеры, выглядит следующим образом:

import lombok.Getter;
import java.util.Calendar;
import java.util.Date;
import java.io.Serializable;
@Getter
public class PersistentTime implements Serializable {    
private Date time;    
public PersistentTime() {        
     time = Calendar.getInstance().getTime();    }}

Механизм используемый по умолчанию:

Далее, что нужно для сохранения объекта? Сохранения выполняется при помощи класса java.io.ObjectOutputStream. Этот класс является фильтрующим потоком, он окружает низкоуровневый поток байтов(называемый узловым потоком(node stream))(?) и предоставляет нам поток сериализации. Узловые потоки могут быть использованы для записи в файловую систему или в сокеты. Это позволяет нам передавать разложенные на байты объекты по сети и затем восстанавливать их на других устройствах.

Посмотрим код, который демонстрирует процесс сериализации:

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializationProcess {    
public static void main(String[] args) {        
String fileName = "time.ser";        

if(args.length > 0){            
fileName = args[0];        }       

PersistentTime time = new PersistentTime();        
FileOutputStream fileOutputStream = null;        
ObjectOutputStream objectOutputStream = null;        

try {            
fileOutputStream = new FileOutputStream(fileName);            
objectOutputStream = new ObjectOutputStream(fileOutputStream);            
objectOutputStream.writeObject(time);            
objectOutputStream.close();        
} catch (IOException e) {            
e.printStackTrace();        }    }}

Метод writeObject() - запускает механизм сериализации и объект разлагается на байты (в данном случай файл).

Теперь стоит посмотреть, на код, выполняющий процесс десириализации:

public class DeserializationProcess {    
public static void main(String[] args) {        
String fileName = "time.ser";        
if(args.length > 0){            
      fileName = args[0];        
}        

PersistentTime time = null;        
FileInputStream fileInputStream = null;        
ObjectInputStream objectInputStream = null;        
try {            
fileInputStream = new FileInputStream(fileName);            
objectInputStream = new ObjectInputStream(fileInputStream);            
time = (PersistentTime) objectInputStream.readObject();            
objectInputStream.close();        
} catch (IOException | ClassNotFoundException e) {            
       e.printStackTrace();        
}        

System.out.println("Время разложения: " + time.getTime());        
System.out.println("Текущее время: " + Calendar.getInstance().getTime()); 
  }}

Консоль:
Время разложения: Sun Sep 17 21:27:42 YEKT 2023
Текущее время: Sun Sep 17 21:39:53 YEKT 2023

Метод readObject() - восстанавливает объект. Метод считывает последовательность байтов, которую мы перед этим сохранили в файле и создает объект, полностью повторяющий оригинал. Поскольку метод считывает любой сериализуемый объект, необходимо его присвоить соответствующему типу. Из системы, в которой происходит десериализация, должен быть доступен файл класса (при сериализации не сохраняется ни файл класса, ни его методы, сохраняется лишь состояние! объекта).

Основные правила:
1. Сохраняемый объект должен реализовать интерфейс Serializable или унаследовать эту реализацию от вышестоящего по иерархии объекта.
2. Вы должны помечать как transient все поля, которые либо не могут быть сериализованы, либо те, которые вы не хотите сериализовать. Сериализация не заботится о модификаторах доступа, таких как private. Все резидентные поля рассматриваются как части состояния сохраняемого объекта, предназначенные для сохранения.

Что такое Hibernate, JMS, JPA и EJB? Hibernate — это популярный framework, цель которого связать ООП и реляционную базу данных.
JMS (Java Message Service) является стандартом обмена сообщениями между приложениями.
Java Persistence API (JPA) — спецификация API Java EE, предоставляет возможность сохранять в удобном виде Java-объекты в базе данных.
Enterprise JavaBeans (также часто употребляется в виде аббревиатуры EJB) — спецификация технологии написания и поддержки серверных компонентов, содержащих бизнес-логику. Является частью Java EE.

Что такое маркерный интерфейс? Маркерный интерфейс — это интерфейс , внутри которого нет методов или констант . Он предоставляет информацию о типах объектов во время выполнения, поэтому компилятор и JVM имеют дополнительную информацию об объекте.

Что такое сокеты? Сокет — это виртуальная конструкция из IP-адреса и номера порта. Её придумали для того, чтобы разработчикам было проще писать код, а программы могли передавать данные друг другу даже в пределах одного компьютера. Сокеты используют для двух вещей: для передачи данных по сети и для связи между приложениями.

Что такое файловая система? Благодаря файловой системе мы сохраняем всю необходимую нам информацию на своих устройствах. Есть различные типы подобных накопителей. От особенностей того или иного вида зависят способ шифрования данных, объем их сжатия, а также качество самого хранения. Наиболее распространенные файловые системы – это FAT32 и NTFS.

Полезные ссылки:
http://www.ccfit.nsu.ru/~deviv/courses/oop/java_ser_rus.html
https://www.simplilearn.com/tutorials/java-tutorial/serialization-in-java
https://metanit.com/java/tutorial/6.10.php

Основные ф-ии, которые выполняет Spring Container:
-IoC - инверсия управления. Создание и управление объектами (аутсорсинг создания и управления объектами. Т.е. передача программистом прав на создание и управление объектами Spring-y.).
-DI (Dependency Injection) - внедрение зависимостей (стоит вспомнить, что в сложной программе, множество объектов зависят друг от друга). (Аутсорсинг добавления/внедрения зависимостей. DI делает объекты нашего приложения слабо зависимым друг от друга).

Способы конфигурации Spring Container (способ дать понимание того, какие объекты нужно создавать, с помощью IoC):

-XML file(устаревший способ);
При создании файла, по стандарту, он имеет название applicationContext.xml. Внутри файла, помимо стандартной настройки, мы создаем необходимый для нас объект(бин):
<bean id = "myPet" //идентификатор бина
class = "spring_introduction.Dog"> //полное имя класса
<\bean>

Таким образом, при запуске нашего приложения, будет создаваться объект Dog и помещаться в Spring Container. Далее, с помощью id мы сможем получить объект из контейнера.
Для получения бина из SpringContainer нам нужно создать Application Context, в аргумент мы можем передать несколько файлов xml, если это необходимо (context всегда нужно закрывать!).
ClassPathXmlApplicationContext context = newClassPathXmlApplicationContext("applicationContext.xml");

Pet pet = context.getBean("myPet", Pet.class); //обращаемся к объекту
pet.say(); //вызываем его метод
context.close; //закрываем контекст

-Annotations + XML file (современный способ);
Аннотации – это специальные комментарии/метки/метаданные, которые нужны для передачи определенной информации.
Конфигурация с помощью аннотаций более короткий и быстрый способ, чем конфигурация с помощью XML файла.
Порядок действий состоит из двух этапов:
-происходит сканирование классов и поиск аннотации @Component;
-далее, создание(регистрация) бина в Spring Container.
В конфиг файле необходимо обозначить пакет, в котором будет проходить сканирование на наличие component (также, скан пройдет и в подпакетах):
<context:component-scan base-package="spring_introduction"/>
Далее, классы, которые имеют аннотацию @Component, будут добавлены в контейнер и ими можно будет пользоваться, через создание Application Context.
При добавлении аннотации @Component(“”), -> в скобках указывается id бина. Если к аннотации @Component не прописать bean id, то бину будет назначен дефолтный id (дефолтный id получается из имени класса, заменяя его первую заглавную букву на прописную). (хорошим тоном считается прописать свой id).

-Java code(современный способ);
Использование java code в качестве конфигурации Spring Container, обладает двумя способами:

1 способ заключается в создании класса MyConfig (название класса может быть любым):
@Configuration
@ComponentScan("spring_introduction")
public class MyConfig {}
@Configuration – означает, что данный класс является конфигурацией.
С помощью аннотации @ComponentScan мы показываем, какой пакет нужно сканировать на наличие бинов и разных аннотаций.
В таком случае, настроить Application Context уже необходимо с помощью другого класса:
AnnotationConfigApplicationContext context = new
AnnotationConfigApplicationContext(MyConfig.class);
Остальные классы, которые мы определяем в бины, имеют всё те же аннотации по определению в контейнер и по внедрению зависимости.

2 способ не использует сканирование пакета и поиск бинов(сокращает кол-во аннотаций в коде).
@Configuration
public class MyConfig {}
В следствие этого, мы не нуждаемся в определении бинов с помощью @Component и в определении зависимости с помощью @Autowired.
В классе MyConfig, прописываем методы, которые добавляют наши бины, с помощью аннотации @Bean(аннотация перехватывает все обращения к бину и регулирует его создание):
@Bean
public Pet catBean(){return new Cat();}
Также, мы можем добавить аннотацию @Scope, для определения состояния бина, выбрав один из двух вариантов, и указав его в скобках (singletone или prototype).
Далее, для внедрения зависимости, мы создаем следующий метод, в том же классе MyConfig:
@Bean
public Person personBean(){return new Person(catBean());}
Следующий шаг, установим значения для нашего объекта типа Person, и как было описано выше, воспользуемся нашим properties файлом. Но теперь мы пропишем конфигурацию не в XML файле, а в классе MyConfig с помощью аннотации @PropertySource.
Для этого мы добавляем аннотацию к описанию класса и в скобках указываем путь до нашего файла:
@Configuration
@PropertySource("classpath:myApp.properties")
public class MyConfig {…}

Способы внедрения зависимостей (DI):

-С помощью конструктора;
<bean id = "myPerson" //идентификатор бина
class = "spring_introduction.Person"> //полное имя класса
<constructor-arg ref="myPet"/> //конструктор класса, с указанием аргумента
</bean>
В примере выше, бин myPerson зависит от бина myPet.
Далее в приложении:
Person person =
context.getBean("myPerson", Person.class); //объявляем бин
person.callYourPet(); //вызываем необходимый метод
context.close() //закрываем контекст

-С помощью сеттеров;
<bean id = "myPerson"
class = "spring_introduction.Person">
<property name="pet" ref="myPet"/> //pet это конвертация от setPet
</bean>

-Autowiring;
…рассмотрим позже.

Внедрение строк и других значений из properties файла:
Создаем файл myApp.properties, в нем установим конкретные значения:
person.surname = Khakimov
person.age = 27
Далее, для его чтения, перед созданием бинов, мы прописываем следующую конфигурацию:
<context:property-placeholder
location="classpath:myApp.properties"/>
И в бине прописываем следующие значения:
<bean id = "myPerson"
class = "spring_introduction.Person">
<property name="pet" ref="myPet"/>
<property name="surname" value="${person.surname}"/> <property name="age" value="${person.age}"/>
</bean>

Что такое бины? Sping Bean – это объект, который создается и управляется Spring Container. Например, когда мы сами создаем new объект, то и называем его объектом. В случае, когда объект создает Spring Container, он называется - бин(bean).

Что такое Bean Scope? Scope(область видимости) определяет:
-жизненный цикл бина;
-возможное кол-во создаваемых бинов;
Разновидности bean scope { singletone, prototype, request, session, global-session} singltone
– дефолтный scope (можно создать только один объект)
-такой бин создается сразу после прочтения Spring Container конфиг файла; -является общим для всех, кто запросит у Spring Container;
-подходит для stateless объектов (объекты, которые менять не придется); prototype
-такой бин создается только после обращения к Spring Container с помощью метода getBean;
-для каждого такого обращения создается новый бин в Spring Container; -подходит для stateful объектов (объекты, которые хранят какое то состояние);

Рассмотрим основные моменты, для понимания потребности в методах. Разделим ассоциативные массивы на три различных типа мапов:

HashMap(выводит элементы без порядка)(Для хранения элементов используются бакеты(Backet/Slot))

LinkedHashMap(вывел элементы в том порядке, в каком и добавляли)(Для хранения элементов используются бакеты(Backet/Slot))

TreeMap(выводит элементы в порядке отсортированном по ключу)(является самым медленным, по той причине, что когда мы добавляем элемент, он сравнивает его ключ с ключами присутствующих элементов, и основываясь на результате сравнения, в процессе добавления, сортирует порядок)

Основная логика ассоциативных массивов, что вы можете добавить в них большое кол-во данных с ключами и дальше по ключу их оттуда доставать. При этом, каждый ключ имеет одно уникальное значение.

В TreeMap ключи должны соответствовать интерфейсу Comparable. Для этого достаточно имплементировать интерфейс Comparable и реализовать ф-ю compareTo() которая возвращает значение Integer. (TreeMap не использует ф-ю equals).

В HashMap, LinkedHashMap, нам нужно переопределить ф-ии hashCode и equals, таким образом, чтобы сравнить все внутренние элементы нашего класса.

Контракт метода equals

1. Рефлексивность (reflexive): Объект должен быть равен самому себе, т.е. для каждого нулевого x, x.equals(x) должно возвращать true.
2. Симметричность (symmetric): Объекты должны быть равны друг другу, т.е. для ненулевых x и y, x.equals(y) должно возвращать true только если y.equals(x) возвращает true.
3. Транзитивность (transitive): Для ненулевых x, y, z (три объекта), если x.equals(y) возвращает true, и y.equals(z) возвращает true, то x.equals(z) должно возвращать true.
4. Повторяемость (consistent): Для ненулевых x и y последовательные вызовы x.equals(y) должны постоянно возвращать true или постоянно возвращать false при условии, что x и y не меняются.

Контракт метода HashCode

1. У двух одинаковых объектов должен быть одинаковый хеш-код.
2. У двух разных объектов могут быть одинаковые хеш-коды. (Как написать функцию, чтобы избежать возникновение коллизии?)
3. Нельзя возвращать константу или рандомное число.

Работая со множеством, мы проверяем, не имеют ли наши объекты одинаковый hashCode. И использование hashCode и equals интересно тогда, когда мы работаем с группой объектов одного типа, и для их быстрого различия, мы и используем ф-ию hashCode.
Сначала мы обращаемся к методу hashCode(проверяем уникальность), и если хеш-коды одинаковые (напомню, что это значит произошла коллизия), переходим в метод equals.

Соответственно, при проектирования какого либо класса, если мы понимаем, что будем сравнивать объекты этого класса, то необходимо реализовать метод hashCode.

Переопределение методов (@Override)
При переопределении методов, в большинстве случаев, мы выбираем все поля нашего класса. Методы hashCode и equals переопределяются всегда вместе, так как связаны одним контрактом.

@Override
public boolean equals(Object o) { 
if (this == o) return true; 
if (o == null || getClass() != o.getClass()) return false; 
Human human = (Human) o; 
return id == human.id && Objects.equals(firstName, human.firstName) && Objects.equals(lastName, human.lastName);}

if (this == o) return true; - говорит нам о том, что наши ссылки равны друг другу.

if (o == null || getClass() != o.getClass()) return false; - если объект равен нулю и объект не принадлежит одному и тому же классу(т.е. классы не равны), то возвращаем false.

@Override
public int hashCode() { 
return Objects.hash(id, firstName, lastName);}

return Objects.hash(id, firstName, lastName); - возвращаем хэш код нашего объекта.

В нашем примере, мы можем сами устанавливать критерии сравнения наших объектов. Например, сравнивать только по id. Или сравнивать по всем параметрам типа, как указано выше.

Что такое бакеты(bucket(-ведро))? Набор элементов хеш-таблицы с совпадающими/близкими значением хеш-функции.
У каждого объекта в JVM, есть функция HashCode, когда мы что то добавляем в HashMap или LinkedHashMap, коллекция высчитывает хеш-код элемента и основываясь на результате, кладет его в структуру данных. При добавлении нового элемента, операция повторяется и вычисляется новый хеш, после чего определяется место для элемента.
Когда мы будем искать по ключу определенное значение из нашей коллекции, сначала для ключа просчитается хеш-код, по хещ-коду будет найден бакет, в котором лежит наш объект и дальше будет доставаться значение для этого объекта, предварительно сравнив с конкретным ключом, который лежит в этом бакете.

Что возвращает ф-я compareTo()? Функция возвращает целочисленное значение Integer. "-1" если левый объект, меньше чем правый. "1" если левый больше чем правый. "0" если они равны

Полезные ссылки:

(https://www.youtube.com/watch?v=6qVRci8gG-M)

(https://ru.stackoverflow.com/questions/988722/%D0%A7%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-buckets-%D0%B8%D0%BB%D0%B8-%D0%B1%D0%B0%D0%BA%D0%B5%D1%82)

(https://medium.com/@vaibhav0109/https-medium-com-vaibhav0109-java-hashcode-collision-how-uniform-is-its-distribution-ee4e5e8dc894)

(https://itsobes.ru/JavaSobes/equals-hashcode/)