Мои два цента из моего собственного блога:
Вот подробное объяснение Сериализации : (мой собственный блог)
Сериализация:
Сериализация - это процесс сохранения состояния объекта. Он представлен и хранится в виде последовательности байтов. Это может быть сохранено в файле. Процесс чтения состояния объекта из файла и его восстановления называется десериализацией.
Зачем нужна сериализация?
В современной архитектуре всегда необходимо сохранять состояние объекта, а затем извлекать его. Например, в Hibernate, чтобы сохранить объект, мы должны сделать класс Serializable. Что он делает, так это то, что после сохранения состояния объекта в виде байтов его можно перенести в другую систему, которая затем может прочитать из состояния и извлечь класс. Состояние объекта может поступать из базы данных, другого jvm или отдельного компонента. С помощью сериализации мы можем получить состояние объекта.
Пример кода и объяснение:
Сначала давайте посмотрим на класс предметов:
public class Item implements Serializable{
/**
* This is the Serializable class
*/
private static final long serialVersionUID = 475918891428093041L;
private Long itemId;
private String itemName;
private transient Double itemCostPrice;
public Item(Long itemId, String itemName, Double itemCostPrice) {
super();
this.itemId = itemId;
this.itemName = itemName;
this.itemCostPrice = itemCostPrice;
}
public Long getItemId() {
return itemId;
}
@Override
public String toString() {
return "Item [itemId=" + itemId + ", itemName=" + itemName + ", itemCostPrice=" + itemCostPrice + "]";
}
public void setItemId(Long itemId) {
this.itemId = itemId;
}
public String getItemName() {
return itemName;
}
public void setItemName(String itemName) {
this.itemName = itemName;
}
public Double getItemCostPrice() {
return itemCostPrice;
}
public void setItemCostPrice(Double itemCostPrice) {
this.itemCostPrice = itemCostPrice;
}
}
В приведенном выше коде видно, что класс Item реализует Serializable .
Это интерфейс, который позволяет классу быть сериализуемым.
Теперь мы видим, что переменная с именем serialVersionUID инициализируется переменной Long. Это число вычисляется компилятором на основе состояния класса и атрибутов класса. Это число, которое поможет jvm идентифицировать состояние объекта, когда он читает состояние объекта из файла.
Для этого мы можем взглянуть на официальную документацию Oracle:
Среда выполнения сериализации связывает с каждым сериализуемым классом номер версии, называемый serialVersionUID, который используется во время десериализации для проверки того, что отправитель и получатель сериализованного объекта загрузили классы для этого объекта, которые совместимы в отношении сериализации. Если получатель загрузил класс для объекта, который имеет serialVersionUID, отличный от класса соответствующего отправителя, то десериализация приведет к исключению InvalidClassException. Сериализуемый класс может объявить свой собственный serialVersionUID в явном виде, объявив поле с именем «serialVersionUID», которое должно быть статическим, конечным и типа long: ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L; Если сериализуемый класс явно не объявляет serialVersionUID, затем среда выполнения сериализации вычислит значение serialVersionUID по умолчанию для этого класса на основе различных аспектов класса, как описано в Спецификации сериализации объектов Java (TM). Однако настоятельно рекомендуется, чтобы все сериализуемые классы явно объявляли значения serialVersionUID, поскольку вычисление serialVersionUID по умолчанию очень чувствительно к деталям класса, которые могут различаться в зависимости от реализаций компилятора, и, следовательно, могут привести к неожиданным исключениям InvalidClassExceptions во время десериализации. Поэтому, чтобы гарантировать согласованное значение serialVersionUID в различных реализациях Java-компилятора, сериализуемый класс должен объявить явное значение serialVersionUID. Также настоятельно рекомендуется, чтобы явные объявления serialVersionUID использовали модификатор private, где это возможно,
Если вы заметили, что мы использовали другое ключевое слово, которое является временным .
Если поле не сериализуемо, оно должно быть помечено как временное. Здесь мы отметили itemCostPrice как временный и не хотим, чтобы он был записан в файл
Теперь давайте посмотрим, как записать состояние объекта в файле, а затем прочитать его оттуда.
public class SerializationExample {
public static void main(String[] args){
serialize();
deserialize();
}
public static void serialize(){
Item item = new Item(1L,"Pen", 12.55);
System.out.println("Before Serialization" + item);
FileOutputStream fileOut;
try {
fileOut = new FileOutputStream("/tmp/item.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(item);
out.close();
fileOut.close();
System.out.println("Serialized data is saved in /tmp/item.ser");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void deserialize(){
Item item;
try {
FileInputStream fileIn = new FileInputStream("/tmp/item.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
item = (Item) in.readObject();
System.out.println("Serialized data is read from /tmp/item.ser");
System.out.println("After Deserialization" + item);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
В приведенном выше примере мы видим пример сериализации и десериализации объекта.
Для этого мы использовали два класса. Для сериализации объекта мы использовали ObjectOutputStream. Мы использовали метод writeObject для записи объекта в файл.
Для десериализации мы использовали ObjectInputStream, который читает объект из файла. Он использует readObject для чтения данных объекта из файла.
Вывод приведенного выше кода будет выглядеть так:
Before SerializationItem [itemId=1, itemName=Pen, itemCostPrice=12.55]
Serialized data is saved in /tmp/item.ser
After DeserializationItem [itemId=1, itemName=Pen, itemCostPrice=null]
Обратите внимание, что itemCostPrice из десериализованного объекта является нулевым поскольку оно не было записано.
Мы уже обсуждали основы Java-сериализации в первой части этой статьи.
Теперь давайте обсудим это глубоко и как это работает.
Сначала давайте начнем с serialversionuid.
serialVersionUID используется в качестве контроля версий в сериализуемом классе.
Если вы явно не объявите serialVersionUID, JVM сделает это за вас автоматически, основываясь на различных свойствах класса Serializable.
Алгоритм вычисления Java-версии (см. Подробнее здесь)
- Название класса.
- Модификаторы класса записываются как 32-разрядное целое число.
- Название каждого интерфейса отсортировано по имени.
- Для каждого поля класса, отсортированного по имени поля (кроме частных статических и частных переходных полей: имя поля. Модификаторы поля записываются в виде 32-разрядного целого числа. Дескриптор поля.
- Если инициализатор класса существует, запишите следующее: Имя метода,.
- Модификатор метода, java.lang.reflect.Modifier.STATIC, записывается как 32-разрядное целое число.
- Дескриптор метода, () V.
- Для каждого не приватного конструктора, отсортированного по имени метода и сигнатуре: Имя метода,. Модификаторы метода записаны как 32-разрядное целое число. Дескриптор метода.
- Для каждого не закрытого метода, отсортированного по имени метода и сигнатуре: Имя метода. Модификаторы метода записаны как 32-разрядное целое число. Дескриптор метода.
- Алгоритм SHA-1 выполняется в потоке байтов, созданных DataOutputStream, и выдает пять 32-битных значений sha [0..4]. Значение хеша составляется из первого и второго 32-битных значений дайджеста сообщения SHA-1. Если результат дайджеста сообщения, пять 32-битных слов H0 H1 H2 H3 H4, находится в массиве из пяти значений int с именем sha, значение хеш-функции будет вычислено следующим образом:
long hash = ((sha[0] >>> 24) & 0xFF) |
> ((sha[0] >>> 16) & 0xFF) << 8 |
> ((sha[0] >>> 8) & 0xFF) << 16 |
> ((sha[0] >>> 0) & 0xFF) << 24 |
> ((sha[1] >>> 24) & 0xFF) << 32 |
> ((sha[1] >>> 16) & 0xFF) << 40 |
> ((sha[1] >>> 8) & 0xFF) << 48 |
> ((sha[1] >>> 0) & 0xFF) << 56;
Алгоритм сериализации Java
Алгоритм сериализации объекта описан ниже:
1. Он записывает метаданные класса, связанного с экземпляром.
2. Он рекурсивно записывает описание суперкласса, пока не найдет java.lang.object .
3. Как только он заканчивает запись информации метаданных, он начинает с фактических данных, связанных с экземпляром. Но на этот раз он начинается с самого высшего суперкласса.
4. Он рекурсивно записывает данные, связанные с экземпляром, начиная с наименьшего суперкласса, до самого производного класса.
Что нужно иметь в виду:
Статические поля в классе не могут быть сериализованы.
public class A implements Serializable{
String s;
static String staticString = "I won't be serializable";
}
Если serialversionuid отличается в классе чтения, он выдаст InvalidClassExceptionисключение.
Если класс реализует сериализуемый, то все его подклассы также будут сериализуемыми.
public class A implements Serializable {....};
public class B extends A{...} //also Serializable
Если класс имеет ссылку на другой класс, все ссылки должны быть сериализуемыми, иначе процесс сериализации не будет выполнен. В таком случае NotSerializableException выбрасывается во время выполнения.
Например:
public class B{
String s,
A a; // class A needs to be serializable i.e. it must implement Serializable
}
