Что такое сериализация объектов?

Что подразумевается под «сериализацией объектов»? Не могли бы вы объяснить это несколькими примерами?

Сериализация – это преобразование объекта в последовательность байтов, так что объект можно легко сохранить в постоянном хранилище или передать по каналу связи. Затем stream байтов можно десериализовать – преобразовать в реплику исходного объекта.

Вы можете рассматривать сериализацию как процесс преобразования экземпляра объекта в последовательность байтов (которая может быть двоичной или не зависящей от реализации).

Это очень полезно, когда вы хотите передать данные одного объекта по сети, например, с одной JVM на другую.

В Java механизм сериализации встроен в платформу, но вам необходимо реализовать интерфейс Serializable, чтобы сделать объект сериализуемым.

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

Наконец, вы можете переопределить механизм по умолчанию и предоставить свой собственный; это может быть подходящим в некоторых особых случаях. Для этого вы используете одну из скрытых функций в java .

Важно отметить, что сериализацией является «значение» объекта или содержимого, а не определение classа. Таким образом, методы не сериализуются.

Вот очень простой пример с комментариями, чтобы облегчить его чтение:

import java.io.*; import java.util.*; // This class implements "Serializable" to let the system know // it's ok to do it. You as programmer are aware of that. public class SerializationSample implements Serializable { // These attributes conform the "value" of the object. // These two will be serialized; private String aString = "The value of that string"; private int someInteger = 0; // But this won't since it is marked as transient. private transient List unInterestingLongLongList; // Main method to test. public static void main( String [] args ) throws IOException { // Create a sample object, that contains the default values. SerializationSample instance = new SerializationSample(); // The "ObjectOutputStream" class has the default // definition to serialize an object. ObjectOutputStream oos = new ObjectOutputStream( // By using "FileOutputStream" we will // Write it to a File in the file system // It could have been a Socket to another // machine, a database, an in memory array, etc. new FileOutputStream(new File("o.ser"))); // do the magic oos.writeObject( instance ); // close the writing. oos.close(); } } 

Когда мы запускаем эту программу, создается файл «o.ser», и мы можем видеть, что произошло.

Если мы изменим значение: someInteger на, например Integer.MAX_VALUE , мы можем сравнить результат, чтобы узнать, в чем разница.

Вот скриншот, показывающий именно эту разницу:

alt text

Можете ли вы определить различия? 😉

В сериализации Java есть дополнительное релевантное поле: serialversionUID, но я думаю, что это уже слишком долго, чтобы покрыть его.

Не стесняйтесь ответить на 6-летний вопрос, добавив только очень высокий уровень понимания для людей, новых для Java

Что такое сериализация?

Преобразование объекта в байты и байты обратно в объект (десериализация).

когда используется сериализация?

Когда мы хотим сохранить объект. Когда мы хотим, чтобы объект существовал за пределами жизни JVM.

Пример реального мира:

Банкомат. Когда владелец учетной записи пытается снять деньги с сервера через банкомат, информация владельца учетной записи, такая как данные о снятии, будет сериализована и отправлена ​​на сервер, где детали десериализуются и используются для выполнения операций.

Как сериализация выполняется в java.

  1. Внедрите java.io.Serializable интерфейс (интерфейс маркера, поэтому никакого метода для реализации).

  2. Персистируйте объект: используйте class java.io.ObjectOutputStream , stream фильтра, который является оберткой в ​​streamе байтов более низкого уровня (для записи объектов в файловые системы или переноса сплющенного объекта по сетевому проводу и перестройки на другой стороне).

    • writeObject(<>) – для записи объекта
    • readObject() – читать сериализованный объект

Запомнить:

Когда вы сериализуете объект, будет сохранено только состояние объекта, а не файл или методы classа объекта.

Когда вы сериализуете 2-байтовый объект, вы видите 51-байтовый сериализованный файл.

Шаги, как объект сериализуется и де-сериализуется.

Ответ для: Как он преобразовал в 51-байтный файл?

  • Сначала записываются магические данные streamа сериализации (STREAM_MAGIC = «AC ED» и STREAM_VERSION = версия JVM).
  • Затем он записывает метаданные classа, связанного с экземпляром (длина classа, имя classа, serialVersionUID).
  • Затем он рекурсивно выписывает метаданные суперclassа, пока не найдет java.lang.Object .
  • Затем начинается с фактических данных, связанных с экземпляром.
  • Наконец, записывает данные объектов, связанных с экземпляром, начиная с метаданных и заканчивая фактическим содержимым.

Если вас интересует более подробная информация о Java Serialization, пожалуйста, проверьте эту ссылку .

Изменить : Еще одна хорошая ссылка для чтения.

Это ответит на несколько частых вопросов:

  1. Как не сериализовать любое поле в classе.
    Ans: использование ключевого слова transient

  2. Когда дочерний class сериализуется, родительский class получает сериализацию?
    Ans: Нет, если родитель не расширяет поля родительских интерфейсов Serializable, сериализация не производится.

  3. Когда родительский сериализован, class child получает сериализацию?
    Ответ: Да, по умолчанию дочерний class также сериализуется.

  4. Как избежать сериализации classа child?
    Ans: a. Переопределите метод writeObject и readObject и NotSerializableException .

    б. Кроме того, вы можете пометить все поля, преходящие в дочернем classе.

  5. Некоторые classы системного уровня, такие как Thread, OutputStream и его подclassы, и Socket не являются сериализуемыми.

Сериализация берет «живой» объект в памяти и преобразует его в формат, который может быть где-то сохранен (например, в памяти, на диске), а затем «десериализован» обратно в живой объект.

Мне понравился подарок @OscarRyz. Хотя здесь я продолжаю историю сериализации, которая была первоначально написана @amitgupta.

Несмотря на то, что знание о структуре classа роботов и сериализованных данных ученый Земли не смог десериализовать данные, которые могут заставить роботов работать.

 Exception in thread "main" java.io.InvalidClassException: SerializeMe; local class incompatible: stream classdesc : 

Ученые Марса ждали полной оплаты. Как только платеж был сделан, ученые Марса поделились с serialversionUID учеными Земли. Ученый Земли поставил его в class роботов, и все стало хорошо.

Сериализация означает сохранение объектов в java. Если вы хотите сохранить состояние объекта и хотите перестроить состояние позже (может быть в другом JVM), можно использовать сериализацию.

Обратите внимание, что свойства объекта будут сохранены. Если вы хотите снова воскресить объект, вы должны иметь файл classа, потому что только переменные-члены будут сохранены, а не функции-члены.

например:

 ObjectInputStream oos = new ObjectInputStream( new FileInputStream( new File("o.ser")) ) ; SerializationSample SS = (SearializationSample) oos.readObject(); 

Searializable – это интерфейс маркера, который означает, что ваш class сериализуем. Маркер-интерфейс означает, что это просто пустой интерфейс, и использование этого интерфейса уведомит JVM о том, что этот class может быть сериализуемым.

Мои два цента из моего собственного блога:

Вот подробное объяснение Сериализации : (мой собственный блог)

Сериализация:

Сериализация – это процесс сохранения состояния объекта. Он представляется и сохраняется в виде последовательности байтов. Это можно сохранить в файле. Процесс чтения состояния объекта из файла и его восстановления называется десериализацией.

Какая потребность в сериализации?

В современной архитектуре всегда необходимо сохранять состояние объекта, а затем извлекать его. Например, в Hibernate для хранения объекта мы должны сделать class Serializable. Что он делает, так это то, что как только состояние объекта сохраняется в виде байтов, оно может быть перенесено в другую систему, которая затем может считывать из состояния и извлекать class. Состояние объекта может поступать из базы данных или другого jvm или из отдельного компонента. С помощью сериализации мы можем получить состояние объекта.

Код Пример и пояснение:

Сначала давайте посмотрим на class предметов:

 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; } } 

В приведенном выше коде видно, что class Item реализует Serializable .

Это интерфейс, который позволяет сериализовать class.

Теперь мы видим, что переменная с именем serialVersionUID инициализируется переменной Long. Этот номер вычисляется компилятором на основе состояния classа и атрибутов classа. Это число, которое поможет jvm идентифицировать состояние объекта при чтении состояния объекта из файла.

Для этого мы можем взглянуть на официальную документацию Oracle:

Среда сериализации связывает каждый сериализуемый class с номером версии, называемым serialVersionUID, который используется во время десериализации для проверки того, что отправитель и получатель сериализованного объекта загружают classы для этого объекта, которые совместимы с сериализацией. Если получатель загрузил class для объекта с другим идентификатором serialVersionUID, чем class соответствующего classа отправителя, то десериализация приведет к исключению InvalidClassException. Сериализуемый class может объявить свой собственный serialVersionUID явно, объявив поле с именем «serialVersionUID», которое должно быть статическим, окончательным и длинным: ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L; Если сериализуемый class явно не объявляет serialVersionUID, то среда выполнения сериализации будет вычислять значение serialVersionUID по умолчанию для этого classа на основе различных аспектов classа, как описано в Спецификации сериализации объектов Java (TM). Тем не менее, настоятельно рекомендуется, чтобы все сериализуемые classы явно объявляли значения serialVersionUID, поскольку вычисление по умолчанию serialVersionUID очень чувствительно к деталям classа, которые могут различаться в зависимости от реализаций компилятора и, таким образом, могут приводить к неожиданным InvalidClassExceptions во время десериализации. Поэтому, чтобы гарантировать последовательное значение serialVersionUID в разных реализациях java-компилятора, сериализуемый class должен объявить явное значение serialVersionUID. Также настоятельно рекомендуется, чтобы явные объявления serialVersionUID использовали, по возможности, частный модификатор, поскольку такие объявления применяются только к полям, объявляющим сразу же: classVersionUID не полезны как унаследованные.

Если вы заметили, что есть другое ключевое слово, которое мы использовали, которое является временным .

Если поле не сериализуемо, оно должно быть помечено как переходное. Здесь мы отметили значение 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(); } } } 

В приведенном выше примере мы можем увидеть пример сериализации и десериализации объекта.

Для этого мы использовали два classа. Для сериализации объекта мы использовали 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 Serialization в первой части этой статьи.

Теперь давайте обсудим это глубоко и как это работает.

Сначала начнем с serialversionuid.

SerialVersionUID используется как элемент управления версиями в classе Serializable.

Если вы явно не объявляете serialVersionUID, JVM сделает это автоматически, основываясь на различных свойствах classа Serializable.

Алгоритм вычисления языка serialversionuid (читайте здесь подробнее)

  1. Имя classа.
    1. Модификаторы classов, написанные как 32-битное целое число.
    2. Имя каждого интерфейса, отсортированного по имени.
    3. Для каждого поля classа, отсортированного по имени поля (кроме частных статических и частных полей переходного процесса: Имя поля. Модификаторы поля, написанные как 32-разрядное целое. Дескриптор поля.
    4. Если существует инициализатор classа, выпишите следующее: Имя метода.
    5. Модификатор метода java.lang.reflect.Modifier.STATIC, написанный как 32-разрядное целое число.
    6. Дескриптор метода, () V.
    7. Для каждого не-частного конструктора, отсортированного по имени метода и сигнатуре: Имя метода. Модификаторы метода, написанные как 32-битное целое число. Дескриптор метода.
    8. Для каждого не-частного метода, отсортированного по имени метода и сигнатуре: Имя метода. Модификаторы метода, написанные как 32-битное целое число. Дескриптор метода.
    9. Алгоритм SHA-1 выполняется в streamе байтов, создаваемых DataOutputStream, и выдает пять 32-битовых значений sha [0..4]. Хеш-значение собирается из первого и второго 32-битных значений сообщения SHA-1. Если результат дайджесты сообщения, пять 32-битовых слов H0 H1 H2 H3 H4, находятся в массиве из пяти значений int sha, значение hashа будет вычисляться следующим образом:
  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. Он записывает метаданные classа, связанного с экземпляром.
2. Он рекурсивно выписывает описание суперclassа, пока не найдет java.lang.object .
3. Как только он завершит запись информации метаданных, она начинается с фактических данных, связанных с экземпляром. Но на этот раз он начинается с самого верхнего суперclassа.
4. Он рекурсивно записывает данные, связанные с экземпляром, начиная от наименьшего суперclassа до самого производного classа.

Что нужно помнить:

  1. Статические поля в classе не могут быть сериализованы.

     public class A implements Serializable{ String s; static String staticString = "I won't be serializable"; } 
  2. Если serialversionuid отличается в classе чтения, он InvalidClassException исключение InvalidClassException .

  3. Если class реализует сериализуемый, то все его подclass также будут сериализованы.

     public class A implements Serializable {....}; public class B extends A{...} //also Serializable 
  4. Если class имеет ссылку другого classа, все ссылки должны быть Serializable, иначе процесс сериализации не будет выполнен. В этом случае исключение NotSerializableException запускается во время выполнения.

Например:

 public class B{ String s, A a; // class A needs to be serializable ie it must implement Serializable } 

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

http://en.wikipedia.org/wiki/Serialization

Сериализация – это процесс сохранения объекта на носителе данных (например, файл или буфер памяти) или для передачи его по сетевому соединению в двоичной форме. Сериализованные объекты независимы от JVM и могут быть повторно сериализованы любым JVM. В этом случае состояние java-объектов «в памяти» преобразуется в stream байтов. Этот тип файла не может быть понят пользователю. Это особый тип объекта, который повторно используется JVM (виртуальная машина Java). Этот процесс сериализации объекта также называется дефляцией или сортировкой объекта.

Объект, который должен быть сериализован, должен реализовывать интерфейс java.io.Serializable . Механизм сериализации по умолчанию для объекта записывает class объекта, подпись classа и значения всех непереходных и нестатических полей.

 class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput, 

Интерфейс DataOutput расширяет интерфейс DataOutput и добавляет методы для сериализации объектов и записи байтов в файл. ObjectOutputStream расширяет java.io.OutputStream и реализует интерфейс ObjectOutput . Он сериализует объекты, массивы и другие значения в stream. Таким образом, конструктор ObjectOutputStream записывается как:

 ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f)); 

Выше код использовался для создания экземпляра classа ObjectOutput с помощью конструктора ObjectOutputStream( ) который принимает экземпляр FileOuputStream в качестве параметра.

Интерфейс ObjectOutput используется при реализации classа ObjectOutputStream . ObjectOutputStream построен для сериализации объекта.

Удаление десериализации объекта в java

Противоположная операция сериализации называется десериализацией, т. Е. Для извлечения данных из серии байтов называется десериализацией, которая также называется раздуванием или parsingкой.

ObjectInputStream расширяет java.io.InputStream и реализует интерфейс ObjectInput . Он десериализует объекты, массивы и другие значения из входного streamа. Таким образом, конструктор ObjectInputStream записывается как:

 ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f)); 

Над кодом программы создается экземпляр classа ObjectInputStream для десериализации этого файла, который был сериализован classом ObjectInputStream . Вышеприведенный код создает экземпляр, используя экземпляр classа FileInputStream который содержит указанный файловый объект, который должен быть десериализован, потому что конструктору ObjectInputStream() нужен входной stream.

Сериализация – это процесс превращения объекта Java в массив байтов, а затем обратно в объект с сохраненным состоянием. Полезно для различных вещей, таких как отправка объектов по сети или кэширование вещей на диск.

Подробнее читайте в этой короткой статье, которая объясняет, как программировать часть процесса, и затем переходите к Serializable javadoc . Вы также можете быть заинтересованы в чтении этого связанного вопроса .

Вернуть файл как объект: http://www.tutorialspoint.com/java/java_serialization.htm

  import java.io.*; public class SerializeDemo { public static void main(String [] args) { Employee e = new Employee(); e.name = "Reyan Ali"; e.address = "Phokka Kuan, Ambehta Peer"; e.SSN = 11122333; e.number = 101; try { FileOutputStream fileOut = new FileOutputStream("/tmp/employee.ser"); ObjectOutputStream out = new ObjectOutputStream(fileOut); out.writeObject(e); out.close(); fileOut.close(); System.out.printf("Serialized data is saved in /tmp/employee.ser"); }catch(IOException i) { i.printStackTrace(); } } } import java.io.*; public class DeserializeDemo { public static void main(String [] args) { Employee e = null; try { FileInputStream fileIn = new FileInputStream("/tmp/employee.ser"); ObjectInputStream in = new ObjectInputStream(fileIn); e = (Employee) in.readObject(); in.close(); fileIn.close(); }catch(IOException i) { i.printStackTrace(); return; }catch(ClassNotFoundException c) { System.out.println("Employee class not found"); c.printStackTrace(); return; } System.out.println("Deserialized Employee..."); System.out.println("Name: " + e.name); System.out.println("Address: " + e.address); System.out.println("SSN: " + e.SSN); System.out.println("Number: " + e.number); } } 

Сериализация объектов Java

введите описание изображения здесь

Serialization – это механизм преобразования графика объектов Java в массив байтов для хранения ( to disk file ) или передачи ( across a network ), а затем с помощью десериализации мы можем восстановить график объектов. Графики объектов восстанавливаются правильно, используя механизм обмена ссылками. Но перед сохранением проверьте, идентичны ли serialVersionUID из файла ввода-файла / сети и .class serialVersionUID. Если нет, бросьте java.io.InvalidClassException .

Каждый class с версией должен идентифицировать исходную версию classа, для которой он способен записывать streamи и из которых он может читать. Например, class версии должен объявить:

Синтаксис serialVersionUID

 // ANY-ACCESS-MODIFIER static final long serialVersionUID = (64-bit has)L; private static final long serialVersionUID = 3487495895819393L; 

serialVersionUID необходим для процесса сериализации. Но разработчик может добавить его в исходный файл java. Если serialVersionUID не включен, среда выполнения сериализации будет генерировать serialVersionUID и связывать ее с classом. Сериализованный объект будет содержать этот serialVersionUID вместе с другими данными.

Примечание. Настоятельно рекомендуется, чтобы все сериализуемые classы явно объявляли serialVersionUID, since the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations и, таким образом, могут приводить к непредвиденным конфликтам serialVersionUID во время десериализации, что приводит к сбою десериализации.

Проверка серийных classов

введите описание изображения здесь


Объект Java является сериализуемым. если class или любой из его суперclassов реализует либо интерфейс java.io.Serializable, либо его подчиненный интерфейс, java.io.Externalizable .

  • Класс должен реализовывать интерфейс java.io.Serializable , чтобы успешно сериализовать его объект. Serializable является интерфейсом маркера и используется для информирования компилятора о том, что class, реализующий его, должен быть добавлен сериализуемым поведением. Здесь Java Virtual Machine (JVM) отвечает за автоматическую сериализацию.

    переходное java.io.Serializable interface слово: java.io.Serializable interface

    При сериализации объекта, если мы не хотим, чтобы определенные члены данных объекта были сериализованы, мы можем использовать модификатор переходного процесса. Ключевое слово переходного процесса предотвратит сериализацию этого элемента данных.

    • Поля, объявленные как переходные или статические, игнорируются процессом сериализации.

    TRANSIENT & VOLATILE

     +--------------+--------+-------------------------------------+ | Flag Name | Value | Interpretation | +--------------+--------+-------------------------------------+ | ACC_VOLATILE | 0x0040 | Declared volatile; cannot be cached.| +--------------+--------+-------------------------------------+ |ACC_TRANSIENT | 0x0080 | Declared transient; not written or | | | | read by a persistent object manager.| +--------------+--------+-------------------------------------+ 
     class Employee implements Serializable { private static final long serialVersionUID = 2L; static int id; int eno; String name; transient String password; // Using transient keyword means its not going to be Serialized. } 
  • Внедрение интерфейса Externalizable позволяет объекту принимать полный контроль над содержимым и форматом сериализованной формы объекта. Методы интерфейса Externalizable, writeExternal и readExternal вызываются для сохранения и восстановления состояния объектов. Когда они реализуются classом, они могут писать и читать собственное состояние, используя все методы ObjectOutput и ObjectInput. Объекты должны обрабатывать любые версии, которые происходят.

     class Emp implements Externalizable { int eno; String name; transient String password; // No use of transient, we need to take care of write and read. @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(eno); out.writeUTF(name); //out.writeUTF(password); } @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { this.eno = in.readInt(); this.name = in.readUTF(); //this.password = in.readUTF(); // java.io.EOFException } } 
  • Только объекты, поддерживающие интерфейс java.io.Serializable или java.io.Externalizable, могут быть written to / read from streamов. Класс каждого сериализуемого объекта кодируется, включая имя classа и подпись classа, значения полей и массивов объекта и закрытие любых других объектов, на которые ссылаются исходные объекты.

Сериализуемый пример для файлов

 public class SerializationDemo { static String fileName = "D:/serializable_file.ser"; public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException { Employee emp = new Employee( ); Employee.id = 1; // Can not Serialize Class data. emp.eno = 77; emp.name = "Yash"; emp.password = "confidential"; objects_WriteRead(emp, fileName); Emp e = new Emp( ); e.eno = 77; e.name = "Yash"; e.password = "confidential"; objects_WriteRead_External(e, fileName); /*String stubHost = "127.0.0.1"; Integer anyFreePort = 7777; socketRead(anyFreePort); //Thread1 socketWrite(emp, stubHost, anyFreePort); //Thread2*/ } public static void objects_WriteRead( Employee obj, String serFilename ) throws IOException{ FileOutputStream fos = new FileOutputStream( new File( serFilename ) ); ObjectOutputStream objectOut = new ObjectOutputStream( fos ); objectOut.writeObject( obj ); objectOut.close(); fos.close(); System.out.println("Data Stored in to a file"); try { FileInputStream fis = new FileInputStream( new File( serFilename ) ); ObjectInputStream ois = new ObjectInputStream( fis ); Object readObject; readObject = ois.readObject(); String calssName = readObject.getClass().getName(); System.out.println("Restoring Class Name : "+ calssName); // InvalidClassException Employee emp = (Employee) readObject; System.out.format("Obj[No:%s, Name:%s, Pass:%s]", emp.eno, emp.name, emp.password); ois.close(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } public static void objects_WriteRead_External( Emp obj, String serFilename ) throws IOException { FileOutputStream fos = new FileOutputStream(new File( serFilename )); ObjectOutputStream objectOut = new ObjectOutputStream( fos ); obj.writeExternal( objectOut ); objectOut.flush(); fos.close(); System.out.println("Data Stored in to a file"); try { // create a new instance and read the assign the contents from stream. Emp emp = new Emp(); FileInputStream fis = new FileInputStream(new File( serFilename )); ObjectInputStream ois = new ObjectInputStream( fis ); emp.readExternal(ois); System.out.format("Obj[No:%s, Name:%s, Pass:%s]", emp.eno, emp.name, emp.password); ois.close(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } } 

Сериализуемый пример по сети

Распределение состояния объекта в разных адресных пространствах либо в разных процессах на одном компьютере, либо даже на нескольких компьютерах, подключенных через сеть, но которые работают вместе путем совместного использования данных и методов вызова.

  • Маршаллинг данных
  • Заготовки и скелеты
 /** * Creates a stream socket and connects it to the specified port number on the named host. */ public static void socketWrite(Employee objectToSend, String stubHost, Integer anyFreePort) { try { // CLIENT - Stub[marshalling] Socket client = new Socket(stubHost, anyFreePort); ObjectOutputStream out = new ObjectOutputStream(client.getOutputStream()); out.writeObject(objectToSend); out.flush(); client.close(); } catch (IOException e) { e.printStackTrace(); } } // Creates a server socket, bound to the specified port. public static void socketRead( Integer anyFreePort ) { try { // SERVER - Stub[unmarshalling ] ServerSocket serverSocket = new ServerSocket( anyFreePort ); System.out.println("Server serves on port and waiting for a client to communicate"); /*System.in.read(); System.in.read();*/ Socket socket = serverSocket.accept(); System.out.println("Client request to communicate on port server accepts it."); ObjectInputStream in = new ObjectInputStream(socket.getInputStream()); Employee objectReceived = (Employee) in.readObject(); System.out.println("Server Obj : "+ objectReceived.name ); socket.close(); serverSocket.close(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } } 

@видеть

  • внедрение Serializable vs Externalizable

| * | Сериализация classа: преобразование объекта в байты и байты обратно в объект (десериализация).

 class NamCls implements Serializable { int NumVar; String NamVar; } 

| => Object-Serialization – процесс преобразования состояния объекта в пар байтов.

  • | -> Реализуем, когда вы хотите, чтобы объект существовал за пределами жизни JVM.
  • | -> Serilized Object может храниться в базе данных.
  • | -> Serializable-obects не могут быть прочитаны и поняты людьми, чтобы мы могли добиться безопасности.

| => Object-Deserialization – это процесс получения состояния объекта и хранения его в объекте (java.lang.Object).

  • | -> Перед сохранением его состояния проверьте погоду serialVersionUID form input-file / network и .class file serialVersionUID – то же самое.
    & nbsp & nbspIf не бросать java.io.InvalidClassException.

| => Объект Java является сериализуемым, если его class или любой из его суперclassов

  • реализует либо интерфейс java.io.Serializable, либо
  • его subinterface, java.io.Externalizable.

| => Статические поля в classе не могут быть сериализованы.

 class NamCls implements Serializable { int NumVar; static String NamVar = "I won't be serializable";; } 

| => Если вы не хотите сериализовать переменную classа, используйте ключевое слово transient

 class NamCls implements Serializable { int NumVar; transient String NamVar; } 

| => Если class реализует сериализуемый, то все его подclass также будут сериализованы.

| => Если class имеет ссылку другого classа, все ссылки должны быть Serializable, иначе процесс сериализации не будет выполнен. В таком случае,
NotSerializableException запускается во время выполнения.

Java provides a mechanism, called object serialization where an object can be represented as a sequence of bytes that includes the object’s data as well as information about the object’s type and the types of data stored in the object. It is mainly used to travel object’s state on the network (known as marshaling).

  • jQuery serialize не регистрирует флажки
  • Обтекание с помощью раздела CData - Сериализация XML C #
  • Можно ли десериализовать XML в List ?
  • XML-сериализация свойства интерфейса
  • Как работает сериализация Java и когда она должна использоваться вместо какой-либо другой техники сохранения?
  • Как сериализовать объект Exception в C #?
  • Сериализовать значение nullable int
  • Сериализация XML в Java?
  • Как я могу лениво читать несколько значений JSON из файла / streamа в Python?
  • Как десериализовать XML-документ
  • Сериализация XML и унаследованные типы
  • Давайте будем гением компьютера.