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

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

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

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

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

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

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

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

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<File> 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 to, например целое число.Массив, мы можем сравнить, чтобы увидеть, в чем разница.

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

_{можете ли вы определить различия? ;)}

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

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

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

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

когда сериализация?

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

Реальный Мир Пример:

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

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

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

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

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

помните:

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

при сериализации 2-байтового объекта отображается 51 байтовый сериализованный файл.

действия как объект сериализации и де-сериализации.

ответ Для: как он преобразуется в файл 51 байт?

• сначала записывает магические данные потока сериализации (STREAM_MAGIC= "AC ED" и STREAM_VERSION=версия виртуальная машина Java.)
• затем он записывает метаданные класса, связанного с экземпляром (длина класса, имя класса, serialVersionUID).
• затем он рекурсивно записывает метаданные суперкласса, пока не найдет java.lang.Object.
начинается с фактических данных, связанных с экземпляром.
• наконец записывает данные объектов, связанных с экземпляром, начиная от метаданных до фактического содержимого.

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

редактировать : еще один хороший ссылке читать.

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

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

2. при сериализации дочернего класса родительский класс сериализуется?
   Ans: нет, если parent не расширяет Сериализуемое поле родителей интерфейса, не сериализуются.

3. при сериализации родителя сериализуется ли дочерний класс?
   Ans: да, по умолчанию дочерний класс также сериализуется.

4. Как избежать сериализации дочернего класса?
   Ans: a. Переопределить writeobject и readObject метод и throw NotSerializableException.
   

   б. также вы можете отметьте все переходные поля в дочернем классе.

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

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

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

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

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

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

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

например:

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

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

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

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

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

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

в чем необходимость сериализации?

в современной архитектуре всегда есть необходимость хранить состояние объекта, а затем извлекать его. Например, в Hibernate для хранения объекта мы должны сделать класс Сериализуемым. Что он делает, так это то, что как только состояние объекта сохраняется в виде байтов, его можно перенести в другую систему, которая затем может читать из состояния и извлекать класс. Состояние объекта может поступать из базы данных или другой 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;
        }
}

в приведенном выше коде видно, что элемент класс реализует сериализуемые.

это интерфейс, который позволяет классу быть сериализуемым.

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

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

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

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

если поле не сериализуемо, оно должно быть помечено как переходное. Здесь мы отметили 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 из десериализованного объекта составляет null как это не было написано.

мы уже обсуждали основы сериализации Java в части I этой статьи.

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

сначала давайте начнем с serialversionuid.

на serialVersionUID используется в качестве элемента управления версиями в Сериализуемом классе.

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

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

1. имя класса.
   1. модификаторы класса, записанные как 32-разрядное целое число.
   2. имя каждого интерфейса, отсортированного по имени.
   3. для каждого поля класса, отсортированного по имени поля (кроме частных статических и частных переходных полей: имя поля. Этот модификаторы поля записывается как 32-разрядное целое число. Дескриптор поля.
   4. если инициализатор класса существует, напишите следующее: имя метода .
   5. модификатор метода, java.ленг.отражать.Модификатор.Статическое, записанное как 32-разрядное целое число.
   6. дескриптор метода, ()В.
   7. для каждого не частного конструктора, отсортированного по имени метода и подписи: имя метода, . Модификаторы метод записывается как 32-разрядное целое число. Дескриптор метода.
   8. для каждого не частного метода, отсортированного по имени метода и подписи: имя метода. Модификаторы метода, записанные в виде 32-разрядное целое число. Дескриптор метода.
   9. алгоритм 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.ленг.объект.
3. Как только он закончит писать информация метаданных, затем начинается с фактических данных, связанных с экземпляром. Но в этот раз начинается с самого верхнего суперкласса.
4. Он рекурсивно записывает данные, связанные с экземпляром, начиная от наименьшего суперкласса до наиболее производного класса.

Вещи, Чтобы Иметь В Виду:

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

   public class A implements Serializable{
        String s;
        static String staticString = "I won't be serializable";
   }
   

2. если serialversionuid отличается в классе read он будет бросать InvalidClassException исключения.

3. если класс реализует Serializable, то все его подклассы также быть сериализуемыми.

   public class A implements Serializable {....};
   
   public class B extends A{...} //also Serializable
   

4. если класс имеет ссылку на другой класс, все ссылки должны быть Сериализуемыми, иначе процесс сериализации не будет выполняться. В таком случае, NotSerializableException бросается в во время выполнения.

например:

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

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

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

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

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

class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,

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

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

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

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

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

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

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

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

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

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

Читать подробнее эта короткая статья, которая объясняет программную часть процесса довольно хорошо а затем перейти ксериализуемый 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 от input-file / network И.файл класса serialVersionUID одинаковы. Если нет, бросьте java.io.InvalidClassException.

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

синтаксис serialVersionUID

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

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

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

Проверка Сериализуемых Классов

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

• класс должен реализовать java.Ио.Сериализуемый интерфейс для успешной сериализации объекта. Serializable-это интерфейс маркера и используется для информирования компилятора о том, что класс, реализующий его, должен быть добавлен serializable. здесь виртуальная машина Java (JVM) отвечает за ее автоматическую сериализацию.

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

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

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

  переходный & летучие

  +--------------+--------+-------------------------------------+
  |  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, вызываются для сохранения и восстановления состояния объектов. При реализации классом они могут писать и читать свое собственное состояние, используя все методы 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.Ио.Сериализуемый или java.Ио.Externalizable интерфейс может быть written to/read from потоки. Класс каждого сериализуемого объекта кодируется, включая имя класса и подпись класса, значения полей и массивов объекта и закрытие любых других объектов, на которые ссылаются исходные объекты.

Сериализуемый Пример Для Файлов

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

@see

• реализация Сериализуемой vs Externalizable

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

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

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

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

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

• / - > перед сохранением его состояния проверьте weather serialVersionUID form input-file / network and .файл класса serialVersionUID одинаковы.
  &nbsp&nbspIf не бросает java.Ио.InvalidClassException.
  

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

• реализует либо java.Ио.Сериализуемый интерфейс или
  
• его подинтерфейс, java.Ио.Externalizable.
  

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

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

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

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

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

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

Java предоставляет механизм, называемый сериализацией объекта, где объект может быть представлен в виде последовательности байтов, которая включает данные объекта, а также информацию о типе объекта и типах данных, хранящихся в объекте. Он в основном используется для перемещения состояния объекта в сети (известный как маршалинг).